@taodigital/agent-cli 1.2.1 → 1.2.2

package/dist/index.js

@@ -6226,9 +6226,9 @@ var require_websocket = __commonJS({
         emitErrorAndClose(websocket, err);
       });
       req.on("response", (res) => {
-        const location = res.headers.location;
+        const location2 = res.headers.location;
         const statusCode = res.statusCode;
-        if (location && opts.followRedirects && statusCode >= 300 && statusCode < 400) {
+        if (location2 && opts.followRedirects && statusCode >= 300 && statusCode < 400) {
           if (++websocket._redirects > opts.maxRedirects) {
             abortHandshake(websocket, req, "Maximum redirects exceeded");
             return;
@@ -6236,9 +6236,9 @@ var require_websocket = __commonJS({
           req.abort();
           let addr;
           try {
-            addr = new URL2(location, address);
+            addr = new URL2(location2, address);
           } catch (e) {
-            const err = new SyntaxError(`Invalid URL: ${location}`);
+            const err = new SyntaxError(`Invalid URL: ${location2}`);
             emitErrorAndClose(websocket, err);
             return;
           }
@@ -7579,6 +7579,66 @@ async function runPostman(message, send, signal) {
   send({ ...result, duration: Date.now() - started });
 }
 
+// src/proxy.ts
+var import_node_net = require("node:net");
+var PROXY_HDR_LEN = 37;
+var PROXY_DATA_TO_AGENT = 1;
+var PROXY_DATA_FROM_AGENT = 2;
+var PROXY_CLOSE = 3;
+var tunnels = /* @__PURE__ */ new Map();
+function handleProxyConnect(ws, tunnelId, host, port) {
+  const tcp = (0, import_node_net.createConnection)({ host, port }, () => {
+    ws.send(JSON.stringify({ type: "proxy_connected", tunnelId }));
+    tcp.on("data", (data) => {
+      if (ws.readyState !== ws.OPEN)
+        return;
+      const hdr = Buffer.allocUnsafe(PROXY_HDR_LEN);
+      hdr[0] = PROXY_DATA_FROM_AGENT;
+      hdr.write(tunnelId, 1, "ascii");
+      ws.send(Buffer.concat([hdr, data]));
+    });
+  });
+  tcp.on("error", (err) => {
+    ws.send(JSON.stringify({ type: "proxy_error", tunnelId, error: err.message }));
+    tunnels.delete(tunnelId);
+  });
+  tcp.on("close", () => {
+    if (!tunnels.has(tunnelId))
+      return;
+    tunnels.delete(tunnelId);
+    if (ws.readyState === ws.OPEN) {
+      const hdr = Buffer.allocUnsafe(PROXY_HDR_LEN);
+      hdr[0] = PROXY_CLOSE;
+      hdr.write(tunnelId, 1, "ascii");
+      ws.send(hdr);
+    }
+  });
+  tunnels.set(tunnelId, { socket: tcp });
+}
+function handleProxyBinaryFrame(ws, raw) {
+  if (raw.length < PROXY_HDR_LEN)
+    return;
+  const msgType = raw[0];
+  if (msgType !== PROXY_DATA_TO_AGENT && msgType !== PROXY_CLOSE)
+    return;
+  const tunnelId = raw.slice(1, PROXY_HDR_LEN).toString("ascii");
+  const tunnel = tunnels.get(tunnelId);
+  if (!tunnel)
+    return;
+  if (msgType === PROXY_DATA_TO_AGENT) {
+    tunnel.socket.write(raw.slice(PROXY_HDR_LEN));
+  } else {
+    tunnel.socket.destroy();
+    tunnels.delete(tunnelId);
+  }
+}
+function closeAllTunnels() {
+  for (const [id, tunnel] of tunnels) {
+    tunnel.socket.destroy();
+    tunnels.delete(id);
+  }
+}
+
 // src/index.ts
 var _pkg = (0, import_node_module2.createRequire)(__filename)("../package.json");
 var PKG_VERSION = _pkg.version;
@@ -7616,7 +7676,8 @@ var WsMessageType = {
   RUN_COMPLETE: "run_complete",
   SETUP: "setup",
   DOCTOR: "doctor",
-  RUN_POSTMAN: "run_postman"
+  RUN_POSTMAN: "run_postman",
+  LOCAL_CRAWL: "local_crawl"
 };
 var TERMINAL_JOB_STATUSES = /* @__PURE__ */ new Set([
   "DONE",
@@ -7625,7 +7686,7 @@ var TERMINAL_JOB_STATUSES = /* @__PURE__ */ new Set([
   "TIMED_OUT",
   "ABORTED"
 ]);
-var IDENTITY_PATH = "/workspace/settings/identity";
+var IDENTITY_PATH = "/agent/ping";
 var CREDS_DIR = (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".config", "zeta");
 var CREDS_FILE = (0, import_node_path2.join)(CREDS_DIR, "credentials.json");
 function resolveProfile(explicit) {
@@ -8713,6 +8774,7 @@ Projects (${projects.length}):`);
     }
   }
   function scheduleReconnect() {
+    closeAllTunnels();
     const delay = Math.min(
       WS_RECONNECT_BASE_MS * Math.pow(2, reconnectAttempt) * (0.5 + Math.random() * 0.5),
       WS_RECONNECT_MAX_MS
@@ -8725,6 +8787,7 @@ Projects (${projects.length}):`);
     ws = new wrapper_default(wsUrl, {
       headers: { Authorization: `Bearer ${token}` }
     });
+    ws.binaryType = "nodebuffer";
     const connection = ws;
     ws.on("open", () => {
       console.log("[ZeTa Agent] Connected to ZeTa Cloud.");
@@ -8735,6 +8798,10 @@ Projects (${projects.length}):`);
       }
     });
     ws.on("message", async (raw) => {
+      if (Buffer.isBuffer(raw) && raw.length > 0 && raw[0] !== 123) {
+        handleProxyBinaryFrame(connection, raw);
+        return;
+      }
       let msg;
       try {
         msg = JSON.parse(raw.toString());
@@ -8755,6 +8822,11 @@ Projects (${projects.length}):`);
         case WsMessageType.DOCTOR:
           await handleEnvironmentRequest(msg, connection);
           break;
+        case "proxy_connect":
+          if (typeof msg.tunnelId === "string" && typeof msg.host === "string" && typeof msg.port === "number") {
+            handleProxyConnect(connection, msg.tunnelId, msg.host, msg.port);
+          }
+          break;
         case WsMessageType.RUN_POSTMAN: {
           const runId = typeof msg.runId === "string" ? msg.runId : null;
           const logPrefix = `[ZeTa Postman] Run ${runId}`;
@@ -8806,6 +8878,28 @@ Projects (${projects.length}):`);
           }
           break;
         }
+        case WsMessageType.LOCAL_CRAWL: {
+          const { crawlId, url: crawlUrl, maxScreens = 20, storageState, deviceProfiles, httpBasicUsername, httpBasicPassword, traversalStrategy, bestFirstKeywords } = msg;
+          if (!crawlId || !crawlUrl)
+            break;
+          if (postmanRunRunning || environmentOperationRunning) {
+            if (ws.readyState === wrapper_default.OPEN) {
+              ws.send(JSON.stringify({ type: "crawl_done", crawlId, totalScreens: 0, error: "Another operation is running; retry later" }));
+            }
+            break;
+          }
+          handleLocalCrawl({ crawlId, url: crawlUrl, maxScreens, storageState, deviceProfiles, httpBasicUsername, httpBasicPassword, traversalStrategy, bestFirstKeywords }, ws).catch(() => {
+          });
+          break;
+        }
+        case "local_discover": {
+          const { discoverJobId, url: discoverUrl, maxDiscoverUrls = 2e3, storageState: discoverStorageState } = msg;
+          if (!discoverJobId || !discoverUrl)
+            break;
+          handleLocalDiscover({ discoverJobId, url: discoverUrl, maxDiscoverUrls, storageState: discoverStorageState }, ws).catch(() => {
+          });
+          break;
+        }
         default:
           break;
       }
@@ -8853,6 +8947,809 @@ async function handleRunTests(msg, ws) {
     await (0, import_promises2.rm)(tmpDir, { recursive: true, force: true });
   }
 }
+var DEVICE_VIEWPORTS = {
+  DESKTOP: { width: 1440, height: 900 },
+  MOBILE_PORTRAIT: { width: 393, height: 852, isMobile: true, deviceScaleFactor: 3 },
+  TABLET: { width: 834, height: 1194, isMobile: true, deviceScaleFactor: 2 }
+};
+async function handleLocalCrawl(msg, ws) {
+  const { crawlId, url, maxScreens = 20 } = msg;
+  const deviceProfiles = Array.isArray(msg.deviceProfiles) && msg.deviceProfiles.length > 0 ? msg.deviceProfiles : ["DESKTOP"];
+  console.log(`[ZeTa Agent] Starting local crawl: ${url} (id: ${crawlId}, maxScreens: ${maxScreens})`);
+  const send = (event) => {
+    if (ws.readyState === 1)
+      ws.send(JSON.stringify({ ...event, crawlId }));
+  };
+  try {
+    let chromium;
+    try {
+      chromium = (await import("playwright")).chromium;
+    } catch {
+      send({ type: "crawl_progress", message: "Installing playwright \u2014 this only happens once\u2026" });
+      const { execFileSync } = await import("child_process");
+      const { resolve } = await import("path");
+      const { platform } = await import("os");
+      const agentDir = resolve(__dirname, "..");
+      const isWin = platform() === "win32";
+      const npm = isWin ? "npm.cmd" : "npm";
+      const npx = isWin ? "npx.cmd" : "npx";
+      execFileSync(npm, ["install", "playwright"], { cwd: agentDir, stdio: "pipe", timeout: 12e4 });
+      send({ type: "crawl_progress", message: "Downloading Chromium browser \u2014 this only happens once\u2026" });
+      execFileSync(npx, ["playwright", "install", "chromium"], { cwd: agentDir, stdio: "pipe", timeout: 3e5 });
+      chromium = (await import("playwright")).chromium;
+    }
+    console.log("[ZeTa Agent] Playwright ready \u2014 launching browser");
+    const browser = await chromium.launch({ headless: true });
+    const contextOptions = {
+      viewport: { width: 1440, height: 900 },
+      userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+    };
+    if (msg.storageState) {
+      try {
+        contextOptions.storageState = JSON.parse(msg.storageState);
+      } catch {
+      }
+    }
+    const context = await browser.newContext(contextOptions);
+    if (msg.httpBasicUsername && msg.httpBasicPassword) {
+      const basicCreds = Buffer.from(`${msg.httpBasicUsername}:${msg.httpBasicPassword}`).toString("base64");
+      await context.setExtraHTTPHeaders({ "Authorization": `Basic ${basicCreds}` });
+    }
+    if (msg.httpAuthToken) {
+      await context.setExtraHTTPHeaders({ Authorization: `Bearer ${msg.httpAuthToken}` });
+    }
+    if (msg.httpAuthHeaders && typeof msg.httpAuthHeaders === "object") {
+      await context.setExtraHTTPHeaders(msg.httpAuthHeaders);
+    }
+    context.on("page", async (popup) => {
+      try {
+        await popup.waitForLoadState("domcontentloaded", { timeout: 1e4 }).catch(() => {
+        });
+        const popupUrl = popup.url();
+        if (!popupUrl || popupUrl === "about:blank")
+          return;
+        const popupTitle = await popup.title().catch(() => popupUrl);
+        const popupScreenshot = await popup.screenshot({ type: "jpeg", quality: 80, fullPage: true }).then((b) => b.toString("base64")).catch(() => null);
+        const popupSnapshot = await popup.content().catch(() => null);
+        send({
+          type: "crawl_screen",
+          screen: {
+            url: popupUrl,
+            title: `[Popup] ${popupTitle}`,
+            screenshot: popupScreenshot,
+            domSnapshot: popupSnapshot,
+            inputs: [],
+            links: [],
+            elements: [],
+            apiEndpoints: [],
+            pageText: "",
+            viewportScreenshots: {}
+          }
+        });
+        screensCount++;
+      } catch {
+      }
+    });
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [url];
+    let screensCount = 0;
+    if (msg.seedUrls && Array.isArray(msg.seedUrls)) {
+      for (const su of msg.seedUrls) {
+        if (!queue.includes(su))
+          queue.push(su);
+      }
+    }
+    const traversalStrategy = msg.traversalStrategy ?? "BFS";
+    const bestFirstKeywords = msg.bestFirstKeywords ?? [];
+    const scoreUrl = (u) => {
+      if (traversalStrategy !== "BEST_FIRST" || bestFirstKeywords.length === 0)
+        return 0;
+      const lower = u.toLowerCase();
+      let score = 0;
+      for (const kw of bestFirstKeywords) {
+        if (lower.includes(kw.toLowerCase()))
+          score -= 10;
+      }
+      return score;
+    };
+    const enqueue = (u) => {
+      if (traversalStrategy === "DFS") {
+        queue.unshift(u);
+      } else if (traversalStrategy === "BEST_FIRST") {
+        const score = scoreUrl(u);
+        const idx = queue.findIndex((q) => scoreUrl(q) > score);
+        if (idx === -1)
+          queue.push(u);
+        else
+          queue.splice(idx, 0, u);
+      } else {
+        queue.push(u);
+      }
+    };
+    const normalizeUrl = (u) => {
+      try {
+        const parsed = new URL(u);
+        parsed.hash = "";
+        let path = parsed.pathname.replace(/\/$/, "") || "/";
+        path = path.replace(/\/[0-9a-f]{20,}(\/|$)/gi, "/:id$1").replace(/\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}(\/|$)/gi, "/:id$1");
+        parsed.pathname = path;
+        return parsed.href;
+      } catch {
+        return u;
+      }
+    };
+    try {
+      const baseOrigin = new URL(url).origin;
+      const sitemapRes = await fetch(`${baseOrigin}/sitemap.xml`, {
+        signal: AbortSignal.timeout(5e3),
+        headers: { "User-Agent": "Mozilla/5.0 (compatible; ZeTaBot/1.0)" }
+      });
+      if (sitemapRes.ok) {
+        const xml = await sitemapRes.text();
+        const locs = [...xml.matchAll(/<loc>([^<]+)<\/loc>/g)].map((m) => m[1].trim());
+        for (const loc of locs) {
+          try {
+            const locUrl = new URL(loc);
+            if (locUrl.origin === baseOrigin && !queue.includes(loc)) {
+              enqueue(loc);
+            }
+          } catch {
+          }
+        }
+        send({ type: "crawl_progress", message: `Sitemap: found ${locs.length} URLs` });
+      }
+    } catch {
+    }
+    const disallowedPaths = /* @__PURE__ */ new Set();
+    try {
+      const origin = new URL(url).origin;
+      const robotsPage = await context.newPage();
+      try {
+        const robotsResp = await robotsPage.goto(`${origin}/robots.txt`, { waitUntil: "domcontentloaded", timeout: 5e3 });
+        if (robotsResp?.ok()) {
+          const robotsText = await robotsPage.content();
+          let userAgentAll = false;
+          for (const line of robotsText.split("\n")) {
+            const trimmed = line.trim();
+            if (trimmed.toLowerCase().startsWith("user-agent: *"))
+              userAgentAll = true;
+            else if (trimmed.toLowerCase().startsWith("user-agent:"))
+              userAgentAll = false;
+            else if (userAgentAll && trimmed.toLowerCase().startsWith("disallow:")) {
+              const path = trimmed.slice("disallow:".length).trim();
+              if (path)
+                disallowedPaths.add(path);
+            }
+          }
+        }
+      } finally {
+        await robotsPage.close().catch(() => {
+        });
+      }
+    } catch {
+    }
+    const contentHashes = /* @__PURE__ */ new Set();
+    while (queue.length > 0 && screensCount < maxScreens) {
+      const pageUrl = queue.shift();
+      const normalizedUrl = normalizeUrl(pageUrl);
+      if (visited.has(normalizedUrl))
+        continue;
+      visited.add(normalizedUrl);
+      const urlPath = new URL(pageUrl).pathname;
+      if ([...disallowedPaths].some((d) => d !== "/" && urlPath.startsWith(d))) {
+        send({ type: "crawl_progress", message: `Skipped (robots.txt): ${pageUrl}` });
+        continue;
+      }
+      const page = await context.newPage();
+      const observedApiEndpoints = [];
+      try {
+        page.on("request", (req) => {
+          try {
+            const reqUrl = req.url();
+            if (req.resourceType() === "fetch" || req.resourceType() === "xhr") {
+              const parsed = new URL(reqUrl);
+              const path = parsed.pathname;
+              if (!observedApiEndpoints.includes(path))
+                observedApiEndpoints.push(path);
+            }
+          } catch {
+          }
+        });
+        await page.addInitScript(() => {
+          window.__ZETA_VITALS__ = { lcp: null, cls: 0, fcp: null };
+          try {
+            new PerformanceObserver((list) => {
+              for (const entry of list.getEntries()) {
+                window.__ZETA_VITALS__.lcp = entry.startTime;
+              }
+            }).observe({ type: "largest-contentful-paint", buffered: true });
+            new PerformanceObserver((list) => {
+              for (const entry of list.getEntries()) {
+                window.__ZETA_VITALS__.cls += entry.value ?? 0;
+              }
+            }).observe({ type: "layout-shift", buffered: true });
+            new PerformanceObserver((list) => {
+              for (const entry of list.getEntries()) {
+                if (entry.name === "first-contentful-paint")
+                  window.__ZETA_VITALS__.fcp = entry.startTime;
+              }
+            }).observe({ type: "paint", buffered: true });
+          } catch {
+          }
+        }).catch(() => {
+        });
+        await page.goto(pageUrl, { waitUntil: "domcontentloaded", timeout: 25e3 });
+        await page.waitForLoadState("networkidle", { timeout: 8e3 }).catch(() => {
+        });
+        await page.evaluate(() => {
+          const patterns = [
+            'button[id*="accept"i]',
+            'button[class*="accept"i]',
+            'button[id*="cookie"i][id*="agree"i]',
+            'button[class*="cookie"i][class*="agree"i]',
+            'button[data-testid*="accept"i]',
+            'button[aria-label*="accept"i]',
+            '[id*="onetrust"i] button[class*="accept"i]',
+            "#onetrust-accept-btn-handler",
+            ".cc-accept-all",
+            ".consent-accept"
+          ];
+          for (const sel of patterns) {
+            const el = document.querySelector(sel);
+            if (el) {
+              el.click();
+              return;
+            }
+          }
+        }).catch(() => {
+        });
+        await page.waitForTimeout(500).catch(() => {
+        });
+        await page.addStyleTag({ content: `
+          *, *::before, *::after {
+            animation-duration: 0s !important;
+            animation-delay: 0s !important;
+            transition-duration: 0s !important;
+            transition-delay: 0s !important;
+          }
+        ` }).catch(() => {
+        });
+        await page.waitForFunction(() => {
+          const busy = document.querySelector('[aria-busy="true"]');
+          const skeletons = document.querySelectorAll('[class*="skeleton"],[class*="Skeleton"],[class*="shimmer"],[class*="loading-pulse"]');
+          return !busy && skeletons.length === 0;
+        }, { timeout: 4e3 }).catch(() => {
+        });
+        await page.evaluate(async () => {
+          await new Promise((resolve) => {
+            let last = document.documentElement.scrollHeight;
+            let iters = 0;
+            const timer = setInterval(() => {
+              window.scrollTo(0, document.documentElement.scrollHeight);
+              if (document.documentElement.scrollHeight === last || iters++ > 5) {
+                clearInterval(timer);
+                window.scrollTo(0, 0);
+                resolve();
+              }
+              last = document.documentElement.scrollHeight;
+            }, 400);
+          });
+        }).catch(() => {
+        });
+        const title = await page.title().catch(() => pageUrl);
+        const metaTags = await page.evaluate(() => {
+          const getMeta = (name) => document.querySelector(`meta[name="${name}"], meta[property="${name}"]`)?.getAttribute("content") ?? null;
+          return { description: getMeta("description"), ogImage: getMeta("og:image"), ogType: getMeta("og:type") };
+        }).catch(() => null);
+        const isErrorPage = /^\s*(404|not found|page not found|error|forbidden|403|500|unauthorized|401)\s*$/i.test(title);
+        if (isErrorPage) {
+          send({ type: "crawl_progress", message: `Skipped error page: ${title} (${pageUrl})` });
+          continue;
+        }
+        const webVitals = await page.evaluate(() => {
+          const nav = performance.getEntriesByType("navigation")[0];
+          return {
+            ttfb: nav ? Math.round(nav.responseStart - nav.requestStart) : null,
+            domInteractive: nav ? Math.round(nav.domInteractive) : null,
+            ...window.__ZETA_VITALS__
+          };
+        }).catch(() => null);
+        const dpr = await page.evaluate(() => window.devicePixelRatio || 1).catch(() => 1);
+        const viewport = await page.evaluate(() => ({ width: window.innerWidth, height: window.innerHeight })).catch(() => ({ width: 1440, height: 900 }));
+        const screenshot = await page.screenshot({ type: "jpeg", quality: 85, fullPage: true }).then((b) => b.toString("base64")).catch(() => null);
+        const domSnapshot = await page.content().catch(() => null);
+        const inputs = await page.evaluate(() => {
+          return Array.from(document.querySelectorAll("input,select,textarea")).slice(0, 150).map((el) => {
+            const labelEl = el.id ? document.querySelector(`label[for="${el.id}"]`) : el.closest("label") || el.previousElementSibling?.tagName === "LABEL" ? el.previousElementSibling : null;
+            return {
+              type: el.type || el.tagName.toLowerCase(),
+              name: el.name || "",
+              id: el.id || "",
+              placeholder: el.placeholder || "",
+              label: labelEl?.textContent?.trim() || el.getAttribute("aria-label") || el.getAttribute("aria-labelledby") ? document.getElementById(el.getAttribute("aria-labelledby") || "")?.textContent?.trim() || "" : "",
+              required: el.required || el.getAttribute("aria-required") === "true" || false,
+              value: el.tagName === "SELECT" ? Array.from(el.options).map((o) => o.value).join(",") : el.value || ""
+            };
+          });
+        }).catch(() => []);
+        const links = await page.evaluate((baseUrl) => {
+          const base = new URL(baseUrl);
+          const hrefs = /* @__PURE__ */ new Set();
+          const visited2 = /* @__PURE__ */ new Set();
+          const queue2 = [document.documentElement];
+          while (queue2.length > 0) {
+            const root = queue2.shift();
+            if (!root || visited2.has(root))
+              continue;
+            visited2.add(root);
+            root.querySelectorAll("a[href]").forEach((el) => {
+              try {
+                const href = new URL(el.href, baseUrl).href;
+                if (new URL(href).hostname === base.hostname && !href.includes("#"))
+                  hrefs.add(href);
+              } catch {
+              }
+            });
+            root.querySelectorAll("*").forEach((el) => {
+              if (el.shadowRoot)
+                queue2.push(el.shadowRoot);
+            });
+          }
+          try {
+            const nextData = window.__NEXT_DATA__;
+            if (nextData?.buildManifest?.pages) {
+              Object.keys(nextData.buildManifest.pages).forEach((route) => {
+                if (!route.includes("[") && route !== "/_app" && route !== "/_error") {
+                  hrefs.add(base.origin + route);
+                }
+              });
+            }
+          } catch {
+          }
+          try {
+            const nuxt = window.__NUXT__;
+            if (Array.isArray(nuxt?.ssrContext?.payload?.modules)) {
+            }
+          } catch {
+          }
+          return Array.from(hrefs).slice(0, 80);
+        }, pageUrl).catch(() => []);
+        const elements = await page.evaluate(() => {
+          const els = [];
+          const seen = /* @__PURE__ */ new Set();
+          const add = (el, role, text, isInteractive, expectedData) => {
+            const t = text.trim().slice(0, 200);
+            if (!t || t.length < 2)
+              return;
+            const key = `${role}::${t.toLowerCase()}`;
+            if (seen.has(key))
+              return;
+            seen.add(key);
+            const rect = el.getBoundingClientRect();
+            const landmark = (() => {
+              let p = el.parentElement;
+              while (p) {
+                const tag = p.tagName?.toLowerCase();
+                const role2 = p.getAttribute("role");
+                if (tag === "main" || role2 === "main")
+                  return "main";
+                if (tag === "nav" || role2 === "navigation")
+                  return "nav";
+                if (tag === "form" || role2 === "form")
+                  return "form";
+                if (tag === "aside" || role2 === "complementary")
+                  return "aside";
+                if (tag === "footer" || role2 === "contentinfo")
+                  return "footer";
+                if (tag === "header" || role2 === "banner")
+                  return "header";
+                if (tag === "dialog" || role2 === "dialog")
+                  return "dialog";
+                p = p.parentElement;
+              }
+              return void 0;
+            })();
+            const ariaState = (() => {
+              const attrs = [];
+              const names = ["aria-expanded", "aria-selected", "aria-checked", "aria-pressed", "aria-disabled", "aria-current"];
+              names.forEach((a) => {
+                const v = el.getAttribute(a);
+                if (v)
+                  attrs.push(`${a}=${v}`);
+              });
+              return attrs.join(";") || void 0;
+            })();
+            els.push({
+              role,
+              text: t,
+              isInteractive,
+              meaning: t,
+              ...expectedData ? { expectedData } : {},
+              ...ariaState ? { ariaState } : {},
+              ...landmark ? { landmark } : {},
+              boundingRect: rect.width > 0 ? { x: Math.round(rect.x), y: Math.round(rect.y), w: Math.round(rect.width), h: Math.round(rect.height) } : void 0
+            });
+          };
+          const getLabel = (el) => {
+            const ariaLabel = el.getAttribute("aria-label");
+            if (ariaLabel)
+              return ariaLabel;
+            const labelledBy = el.getAttribute("aria-labelledby");
+            if (labelledBy)
+              return document.getElementById(labelledBy)?.textContent?.trim() || "";
+            if (el.id)
+              return document.querySelector(`label[for="${el.id}"]`)?.textContent?.trim() || "";
+            const closestLabel = el.closest("label");
+            if (closestLabel)
+              return closestLabel.textContent?.trim() || "";
+            return el.textContent?.trim() || el.placeholder || el.name || el.value || "";
+          };
+          const inferExpectedData = (el) => {
+            const type = el.type?.toLowerCase() || "";
+            const label = getLabel(el).toLowerCase();
+            if (type === "email" || label.includes("email"))
+              return "valid_email";
+            if (type === "password" || label.includes("password") || label.includes("passwd"))
+              return "password";
+            if (type === "tel" || label.includes("phone") || label.includes("mobile"))
+              return "phone";
+            if (type === "date" || label.includes("date") || label.includes("dob"))
+              return "date";
+            if (label.includes("otp") || label.includes("pin") || label.includes("code"))
+              return "otp";
+            if (type === "search" || label.includes("search") || label.includes("query"))
+              return "search_term";
+            if (type === "number" || label.includes("amount") || label.includes("price"))
+              return "number";
+            return void 0;
+          };
+          document.querySelectorAll('button,[role="button"],[type="submit"],[type="reset"],[type="button"]').forEach((el) => {
+            const text = getLabel(el);
+            if (text)
+              add(el, "button", text, true);
+          });
+          document.querySelectorAll("h1,h2,h3,h4,h5,h6").forEach((el) => {
+            const text = el.textContent?.trim() || "";
+            if (text)
+              add(el, el.tagName.toLowerCase(), text, false);
+          });
+          document.querySelectorAll("a[href]").forEach((el) => {
+            const text = (el.textContent?.trim() || el.getAttribute("aria-label") || "").slice(0, 150);
+            if (text && text.length > 1)
+              add(el, "nav-link", text, true);
+          });
+          document.querySelectorAll('input:not([type="hidden"]):not([type="submit"]):not([type="button"]):not([type="reset"])').forEach((el) => {
+            const label = getLabel(el);
+            if (label)
+              add(el, `input-${el.type || "text"}`, label, true, inferExpectedData(el));
+          });
+          document.querySelectorAll("textarea").forEach((el) => {
+            const label = getLabel(el);
+            if (label)
+              add(el, "textarea", label, true);
+          });
+          document.querySelectorAll("select").forEach((el) => {
+            const label = getLabel(el);
+            if (label)
+              add(el, "select", label, true);
+          });
+          document.querySelectorAll('input[type="checkbox"],input[type="radio"]').forEach((el) => {
+            const label = getLabel(el);
+            if (label)
+              add(el, el.type, label, true);
+          });
+          document.querySelectorAll('[role="tab"],[role="menuitem"],[role="option"],[role="switch"],[role="combobox"],[role="listbox"],[role="slider"],[role="spinbutton"]').forEach((el) => {
+            const text = getLabel(el);
+            if (text)
+              add(el, el.getAttribute("role") || "widget", text, true);
+          });
+          document.querySelectorAll('[class*="card"],[class*="chip"],[class*="badge"],[class*="tag"],[class*="pill"],[class*="metric"],[class*="stat"]').forEach((el) => {
+            const text = el.textContent?.trim()?.slice(0, 100);
+            if (text && text.length > 2)
+              add(el, "card", text, false);
+          });
+          document.querySelectorAll('[role="alert"],[role="status"],[class*="alert"],[class*="toast"],[class*="banner"],[class*="notification"]').forEach((el) => {
+            const text = el.textContent?.trim()?.slice(0, 150);
+            if (text)
+              add(el, "alert", text, false);
+          });
+          document.querySelectorAll('img[alt]:not([alt=""])').forEach((el) => {
+            const text = (el.alt || "").trim().slice(0, 100);
+            if (text && text.length > 2)
+              add(el, "image", text, false);
+          });
+          const shadowQueue = [document.documentElement];
+          const shadowSeen = /* @__PURE__ */ new Set();
+          while (shadowQueue.length) {
+            const root = shadowQueue.shift();
+            if (!root || shadowSeen.has(root))
+              continue;
+            shadowSeen.add(root);
+            root.querySelectorAll('button,[role="button"]').forEach((el) => {
+              const text = getLabel(el);
+              if (text)
+                add(el, "button", text, true);
+            });
+            root.querySelectorAll("*").forEach((el) => {
+              if (el.shadowRoot)
+                shadowQueue.push(el.shadowRoot);
+            });
+          }
+          return els.slice(0, 400);
+        }).catch(() => []);
+        const a11ySnapshot = await page.accessibility.snapshot({ interestingOnly: false }).catch(() => null);
+        let a11yViolations = [];
+        if (a11ySnapshot) {
+          const flattenTree = (node, out = []) => {
+            if (node) {
+              out.push(node);
+              (node.children ?? []).forEach((c) => flattenTree(c, out));
+            }
+            return out;
+          };
+          const nodes = flattenTree(a11ySnapshot);
+          const unlabeled = nodes.filter(
+            (n) => ["textbox", "combobox", "listbox", "spinbutton", "searchbox"].includes(n.role) && !n.name
+          );
+          if (unlabeled.length > 0) {
+            a11yViolations.push({
+              id: "label-missing",
+              impact: "critical",
+              description: `${unlabeled.length} form control(s) have no accessible name`,
+              nodes: unlabeled.length
+            });
+          }
+          const imgNoAlt = nodes.filter((n) => n.role === "img" && !n.name);
+          if (imgNoAlt.length > 0) {
+            a11yViolations.push({
+              id: "image-alt",
+              impact: "critical",
+              description: `${imgNoAlt.length} image(s) missing alt text`,
+              nodes: imgNoAlt.length
+            });
+          }
+          const hasH1 = nodes.some((n) => n.role === "heading" && n.level === 1);
+          if (!hasH1) {
+            a11yViolations.push({
+              id: "page-has-heading-one",
+              impact: "moderate",
+              description: "Page does not contain an h1 heading",
+              nodes: 1
+            });
+          }
+          const noName = nodes.filter(
+            (n) => ["button", "link"].includes(n.role) && !n.name
+          );
+          if (noName.length > 0) {
+            a11yViolations.push({
+              id: "interactive-no-name",
+              impact: "serious",
+              description: `${noName.length} interactive element(s) have no accessible name`,
+              nodes: noName.length
+            });
+          }
+        }
+        const pageText = await page.evaluate(() => {
+          const lines = [];
+          const walk = (node, depth = 0) => {
+            const tag = node.tagName?.toLowerCase();
+            if (!tag)
+              return;
+            if (["script", "style", "noscript", "svg", "iframe"].includes(tag))
+              return;
+            if (["h1", "h2", "h3", "h4", "h5", "h6"].includes(tag)) {
+              const t = node.textContent?.trim();
+              if (t)
+                lines.push(`${"#".repeat(parseInt(tag[1]))} ${t}`);
+            } else if (tag === "p" || tag === "li") {
+              const t = node.textContent?.trim()?.slice(0, 300);
+              if (t && t.length > 10)
+                lines.push(t);
+            } else {
+              Array.from(node.children).forEach((c) => walk(c, depth + 1));
+              return;
+            }
+          };
+          document.querySelectorAll('main, article, [role="main"], body > div').forEach((root) => walk(root));
+          return lines.slice(0, 200).join("\n");
+        }).catch(() => "");
+        const contentHash = pageText ? pageText.slice(0, 500).replace(/\s+/g, " ") : "";
+        if (contentHash && contentHash.length > 50 && contentHashes.has(contentHash)) {
+          send({ type: "crawl_progress", message: `Skipped duplicate content: ${pageUrl}` });
+          continue;
+        }
+        if (contentHash && contentHash.length > 50) {
+          contentHashes.add(contentHash);
+        }
+        const viewportScreenshots = {};
+        const extraProfiles = deviceProfiles.filter((p) => p !== "DESKTOP" && DEVICE_VIEWPORTS[p]);
+        for (const profile of extraProfiles) {
+          const vp = DEVICE_VIEWPORTS[profile];
+          const vpCtx = await browser.newContext({
+            viewport: { width: vp.width, height: vp.height },
+            isMobile: vp.isMobile ?? false,
+            deviceScaleFactor: vp.deviceScaleFactor ?? 1,
+            userAgent: vp.isMobile ? "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1" : contextOptions.userAgent
+          }).catch(() => null);
+          if (!vpCtx)
+            continue;
+          const vpPage = await vpCtx.newPage().catch(() => null);
+          if (!vpPage) {
+            await vpCtx.close().catch(() => {
+            });
+            continue;
+          }
+          try {
+            await vpPage.goto(pageUrl, { waitUntil: "domcontentloaded", timeout: 2e4 });
+            await vpPage.waitForLoadState("networkidle", { timeout: 5e3 }).catch(() => {
+            });
+            await vpPage.addStyleTag({ content: "*, *::before, *::after { animation-duration: 0s !important; transition-duration: 0s !important; }" }).catch(() => {
+            });
+            const vpShot = await vpPage.screenshot({ type: "jpeg", quality: 80, fullPage: true }).then((b) => b.toString("base64")).catch(() => null);
+            viewportScreenshots[profile] = vpShot;
+          } finally {
+            await vpPage.close().catch(() => {
+            });
+            await vpCtx.close().catch(() => {
+            });
+          }
+        }
+        screensCount++;
+        send({
+          type: "crawl_screen",
+          screen: { url: pageUrl, title, screenshot, domSnapshot, inputs, links, elements, apiEndpoints: observedApiEndpoints, dpr, viewport, pageText, viewportScreenshots, a11yViolations, webVitals, meta: metaTags }
+        });
+        for (const link of links) {
+          const norm = normalizeUrl(link);
+          if (!visited.has(norm) && !queue.some((q) => normalizeUrl(q) === norm)) {
+            enqueue(link);
+          }
+        }
+        send({ type: "crawl_progress", message: `Crawled ${screensCount}/${maxScreens}: ${title || pageUrl}` });
+      } finally {
+        await page.close().catch(() => {
+        });
+      }
+    }
+    try {
+      const exportedState = await context.storageState();
+      if (exportedState.cookies.length > 0 || exportedState.origins.length > 0) {
+        send({ type: "crawl_session_state", storageState: JSON.stringify(exportedState) });
+      }
+    } catch {
+    }
+    await browser.close().catch(() => {
+    });
+    send({ type: "crawl_done", totalScreens: screensCount });
+  } catch (err) {
+    console.error("[ZeTa Agent] Crawl error:", err?.message ?? err);
+    send({ type: "crawl_done", totalScreens: 0, error: err?.message ?? "Local crawl failed" });
+  }
+}
+async function handleLocalDiscover(msg, ws) {
+  const { discoverJobId, url, maxDiscoverUrls = 2e3, storageState } = msg;
+  const send = (payload) => {
+    if (ws.readyState === 1)
+      ws.send(JSON.stringify({ ...payload, discoverJobId }));
+  };
+  try {
+    let chromium;
+    try {
+      chromium = (await import("playwright")).chromium;
+    } catch {
+      const { execFileSync: execFileSync2 } = await import("child_process");
+      const { resolve: resolve2 } = await import("path");
+      const agentDir2 = resolve2(__dirname, "..");
+      const npx = process.platform === "win32" ? "npx.cmd" : "npx";
+      execFileSync2(npx, ["playwright", "install", "chromium"], { cwd: agentDir2, stdio: "pipe", timeout: 3e5 });
+      chromium = (await import("playwright")).chromium;
+    }
+    const browser = await chromium.launch({ headless: true });
+    const contextOptions = {
+      viewport: { width: 1440, height: 900 },
+      userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+    };
+    if (storageState) {
+      try {
+        contextOptions.storageState = JSON.parse(storageState);
+      } catch {
+      }
+    }
+    const context = await browser.newContext(contextOptions);
+    const page = await context.newPage();
+    const origin = new URL(url).origin;
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [url];
+    const allUrls = /* @__PURE__ */ new Set([url]);
+    let pagesVisited = 0;
+    const normalizeDiscoverUrl = (u) => {
+      try {
+        const p = new URL(u);
+        p.hash = "";
+        p.search = p.search.replace(/[?&](utm_[^&]*|ref|source|medium|campaign|fbclid|gclid)=[^&]*/g, "").replace(/^[?&]/, "?");
+        return p.href.replace(/\/$/, "") || p.origin;
+      } catch {
+        return u;
+      }
+    };
+    try {
+      const sitemapResp = await page.goto(`${origin}/sitemap.xml`, { waitUntil: "domcontentloaded", timeout: 8e3 });
+      if (sitemapResp?.ok()) {
+        const sitemapContent = await page.content();
+        const locs = [...sitemapContent.matchAll(/<loc[^>]*>([^<]+)<\/loc>/gi)];
+        for (const match of locs) {
+          const loc = match[1].trim();
+          try {
+            const locUrl = new URL(loc);
+            if (locUrl.origin === origin) {
+              allUrls.add(loc);
+              if (!visited.has(normalizeDiscoverUrl(loc)) && !queue.some((q) => normalizeDiscoverUrl(q) === normalizeDiscoverUrl(loc))) {
+                queue.push(loc);
+              }
+            }
+          } catch {
+          }
+        }
+        if (allUrls.size > 1) {
+          send({ type: "discover_progress", partialUrls: Array.from(allUrls), pct: 5 });
+        }
+      }
+    } catch {
+    }
+    while (queue.length > 0 && allUrls.size < maxDiscoverUrls) {
+      const pageUrl = queue.shift();
+      const norm = normalizeDiscoverUrl(pageUrl);
+      if (visited.has(norm))
+        continue;
+      visited.add(norm);
+      try {
+        await page.goto(pageUrl, { waitUntil: "domcontentloaded", timeout: 2e4 });
+        await page.waitForTimeout(500);
+        pagesVisited++;
+        const links = await page.evaluate((origin2) => {
+          const hrefs = [];
+          const queue2 = [document.documentElement];
+          while (queue2.length > 0) {
+            const node = queue2.shift();
+            if (node.tagName === "A") {
+              try {
+                const abs = new URL(node.href, location.href).href;
+                if (abs.startsWith(origin2))
+                  hrefs.push(abs);
+              } catch {
+              }
+            }
+            queue2.push(...Array.from(node.children));
+            if (node.shadowRoot) {
+              queue2.push(...Array.from(node.shadowRoot.children));
+            }
+          }
+          return hrefs;
+        }, origin).catch(() => []);
+        for (const link of links) {
+          const n = normalizeDiscoverUrl(link);
+          if (!visited.has(n) && !queue.some((q) => normalizeDiscoverUrl(q) === n)) {
+            allUrls.add(link);
+            queue.push(link);
+          }
+        }
+        if (pagesVisited % 10 === 0) {
+          const pct = Math.min(Math.round(allUrls.size / maxDiscoverUrls * 90), 90);
+          send({ type: "discover_progress", partialUrls: Array.from(allUrls), pct });
+        }
+      } catch {
+      }
+    }
+    await page.close().catch(() => {
+    });
+    await browser.close().catch(() => {
+    });
+    send({ type: "discover_done", discoveredUrls: Array.from(allUrls) });
+  } catch (err) {
+    console.error("[ZeTa Agent] Discover error:", err?.message ?? err);
+    send({ type: "discover_done", discoveredUrls: [], error: err?.message ?? "Local discovery failed" });
+  }
+}
 function buildRunCommand(language, scriptPath, _baseUrl) {
   if (language.startsWith("playwright")) {
     return { cmd: "npx", args: ["playwright", "test", scriptPath, "--reporter=json", "--reporter=line"] };