@taodigital/agent-cli 1.2.0 → 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,10 +7579,83 @@ 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;
 var API_URL = process.env.ZETA_API_URL ?? "https://zeta.taodigitalsolutions.com/api";
+var PROFILE_API_URLS = {
+  default: "https://zeta.taodigitalsolutions.com/api",
+  prod: "https://zeta.taodigitalsolutions.com/api",
+  dev: "https://dev.zeta.taodigitalsolutions.com/api",
+  preview: "https://pre.zeta.taodigitalsolutions.com/api",
+  pre: "https://pre.zeta.taodigitalsolutions.com/api",
+  local: "http://localhost:3001/api"
+};
+function resolveApiUrl(explicitFlag, profile) {
+  if (explicitFlag)
+    return explicitFlag;
+  return PROFILE_API_URLS[profile] ?? API_URL;
+}
 var DEFAULT_MAX_SCREENS = process.env.ZETA_DEFAULT_MAX_SCREENS ?? "50";
 var DEFAULT_STRATEGY = process.env.ZETA_DEFAULT_STRATEGY ?? "BFS";
 var LOGIN_TIMEOUT_MS = parseInt(process.env.ZETA_LOGIN_TIMEOUT_MS ?? "") || 1e4;
@@ -7603,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",
@@ -7612,20 +7686,82 @@ 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");
-async function loadCreds() {
+function resolveProfile(explicit) {
+  return explicit ?? process.env.ZETA_PROFILE ?? "default";
+}
+async function loadCreds(profile) {
   try {
     const raw = await (0, import_promises2.readFile)(CREDS_FILE, "utf-8");
-    return JSON.parse(raw);
+    const data = JSON.parse(raw);
+    if (data._version === 2) {
+      const name = resolveProfile(profile) === "default" && !profile && !process.env.ZETA_PROFILE ? data._default ?? "default" : resolveProfile(profile);
+      return data.profiles?.[name] ?? null;
+    }
+    if (profile && profile !== "default")
+      return null;
+    return data;
   } catch {
     return null;
   }
 }
-async function saveCreds(creds) {
+async function listAllProfiles() {
+  try {
+    const raw = await (0, import_promises2.readFile)(CREDS_FILE, "utf-8");
+    const data = JSON.parse(raw);
+    if (data._version === 2)
+      return data.profiles ?? {};
+    return { default: data };
+  } catch {
+    return {};
+  }
+}
+async function saveCreds(creds, profile) {
   await (0, import_promises2.mkdir)(CREDS_DIR, { recursive: true });
-  await (0, import_promises2.writeFile)(CREDS_FILE, JSON.stringify(creds, null, 2), { encoding: "utf-8", mode: 384 });
+  let data = { _version: 2, _default: "default", profiles: {} };
+  try {
+    const existing = JSON.parse(await (0, import_promises2.readFile)(CREDS_FILE, "utf-8"));
+    if (existing._version === 2) {
+      data = existing;
+    } else {
+      data.profiles.default = existing;
+    }
+  } catch {
+  }
+  const name = resolveProfile(profile);
+  data.profiles[name] = creds;
+  if (!data._default)
+    data._default = name;
+  await (0, import_promises2.writeFile)(CREDS_FILE, JSON.stringify(data, null, 2), { encoding: "utf-8", mode: 384 });
+}
+async function deleteCredsProfile(profile) {
+  try {
+    const raw = await (0, import_promises2.readFile)(CREDS_FILE, "utf-8");
+    const data = JSON.parse(raw);
+    if (data._version === 2) {
+      const name = resolveProfile(profile);
+      if (!data.profiles[name])
+        return false;
+      delete data.profiles[name];
+      if (data._default === name) {
+        const remaining = Object.keys(data.profiles);
+        data._default = remaining[0] ?? "default";
+      }
+      if (Object.keys(data.profiles).length === 0) {
+        await (0, import_promises2.unlink)(CREDS_FILE).catch(() => {
+        });
+      } else {
+        await (0, import_promises2.writeFile)(CREDS_FILE, JSON.stringify(data, null, 2), { encoding: "utf-8", mode: 384 });
+      }
+      return true;
+    }
+    await (0, import_promises2.unlink)(CREDS_FILE);
+    return true;
+  } catch {
+    return false;
+  }
 }
 function executeCommand(command, logger, timeoutMs) {
   return new Promise((resolve, reject) => {
@@ -7821,13 +7957,15 @@ function parseEnvironmentOptions(value) {
 }
 var program2 = new Command();
 program2.version(PKG_VERSION).description("ZeTa-AI Local Agent \u2014 run tests and crawls on private networks").enablePositionalOptions();
-program2.command("login").description("Authenticate with ZeTa and store credentials locally (~/.config/zeta/credentials.json)").argument("[token]", "Agent token (zeta_...) \u2014 skip interactive prompt").option("-a, --api <url>", "ZeTa API URL").option("-t, --token <token>", "ZeTa Agent Token (zeta_...)").action(async (tokenArg, options) => {
+program2.command("login").description("Authenticate with ZeTa and store credentials locally (~/.config/zeta/credentials.json)").argument("[token]", "Agent token (zeta_...) \u2014 skip interactive prompt").option("-a, --api <url>", "ZeTa API URL").option("-t, --token <token>", "ZeTa Agent Token (zeta_...)").option("--profile <name>", 'Credential profile to save under (default: $ZETA_PROFILE or "default")').action(async (tokenArg, options) => {
+  const profile = resolveProfile(options.profile);
   const iface = rl.createInterface({ input: process.stdin, output: process.stdout });
+  const profileDefault = resolveApiUrl(void 0, profile);
   let apiUrl = options.api ?? "";
   if (!apiUrl) {
-    apiUrl = (await iface.question(`API URL [${API_URL}]: `)).trim();
+    apiUrl = (await iface.question(`API URL [${profileDefault}]: `)).trim();
     if (!apiUrl)
-      apiUrl = API_URL;
+      apiUrl = profileDefault;
   }
   let token = tokenArg ?? options.token ?? "";
   if (!token) {
@@ -7871,9 +8009,9 @@ program2.command("login").description("Authenticate with ZeTa and store credenti
     }
   } catch {
   }
-  await saveCreds({ apiUrl, token, workspaceId, workspaceName, projects });
+  await saveCreds({ apiUrl, token, workspaceId, workspaceName, projects }, profile);
   console.log(`
-[ZeTa] \u2713 Logged in to "${workspaceName ?? workspaceId}"`);
+[ZeTa] \u2713 Logged in to "${workspaceName ?? workspaceId}" (profile: ${profile})`);
   console.log(`[ZeTa] Credentials stored: ${CREDS_FILE}`);
   if (projects.length > 0) {
     console.log(`
@@ -7883,32 +8021,64 @@ Projects (${projects.length}):`);
   const serviceProject = projects[0];
   if (serviceProject) {
     console.log(`
-[ZeTa] Installing background service for "${serviceProject.name}"...`);
+[ZeTa] Installing background service for "${serviceProject.name}" (profile: ${profile})...`);
     try {
-      await serviceInstall(serviceProject.id);
+      await serviceInstall(serviceProject.id, profile);
       if (projects.length > 1) {
         console.log(`[ZeTa] \u2139  To switch project: zeta service uninstall && zeta service install -p <project-id>`);
       }
     } catch (e) {
       console.warn(`[ZeTa] \u26A0  Background service install failed: ${e instanceof Error ? e.message : String(e)}`);
-      console.warn(`[ZeTa]    Start manually: zeta -p ${serviceProject.id}`);
+      console.warn(`[ZeTa]    Start manually: zeta --profile ${profile} -p ${serviceProject.id}`);
     }
   }
 });
-program2.command("logout").description("Remove stored ZeTa credentials").action(async () => {
-  try {
-    await (0, import_promises2.unlink)(CREDS_FILE);
-    console.log("[ZeTa] \u2713 Logged out. Credentials removed.");
-  } catch {
-    console.log("[ZeTa] No stored credentials found.");
+program2.command("logout").description("Remove stored ZeTa credentials").option("--profile <name>", 'Remove only this profile (default: $ZETA_PROFILE or "default"); use --all to remove everything').option("--all", "Remove all profiles and the credentials file").action(async (options) => {
+  if (options.all) {
+    try {
+      await (0, import_promises2.unlink)(CREDS_FILE);
+      console.log("[ZeTa] \u2713 All credentials removed.");
+    } catch {
+      console.log("[ZeTa] No stored credentials found.");
+    }
+    return;
+  }
+  const profile = resolveProfile(options.profile);
+  const removed = await deleteCredsProfile(profile);
+  if (removed) {
+    console.log(`[ZeTa] \u2713 Profile "${profile}" removed.`);
+  } else {
+    console.log(`[ZeTa] Profile "${profile}" not found.`);
   }
 });
-program2.command("whoami").description("Show currently stored credentials").action(async () => {
-  const creds = await loadCreds();
+program2.command("whoami").description("Show currently stored credentials").option("--profile <name>", 'Profile to inspect (default: $ZETA_PROFILE or "default")').option("--all", "Show all configured profiles").action(async (options) => {
+  if (options.all) {
+    const all = await listAllProfiles();
+    const names = Object.keys(all);
+    if (names.length === 0) {
+      console.log("[ZeTa] No profiles configured. Run `zeta login`.");
+      process.exit(1);
+    }
+    names.forEach((name) => {
+      const c = all[name];
+      console.log(`
+Profile: ${name}`);
+      console.log(`  Workspace : ${c.workspaceName ?? c.workspaceId ?? "(unknown)"}`);
+      console.log(`  API       : ${c.apiUrl}`);
+      console.log(`  Token     : ${c.token.slice(0, 10)}...`);
+      if (c.projects?.length) {
+        console.log(`  Projects  : ${c.projects.map((p) => p.name).join(", ")}`);
+      }
+    });
+    return;
+  }
+  const profile = resolveProfile(options.profile);
+  const creds = await loadCreds(profile);
   if (!creds) {
-    console.log("[ZeTa] Not logged in. Run `zeta login`.");
+    console.log(`[ZeTa] Profile "${profile}" not found. Run \`zeta login --profile ${profile}\`.`);
     process.exit(1);
   }
+  console.log(`Profile   : ${profile}`);
   console.log(`Workspace : ${creds.workspaceName ?? creds.workspaceId ?? "(unknown)"}`);
   console.log(`API       : ${creds.apiUrl}`);
   console.log(`Token     : ${creds.token.slice(0, 10)}...`);
@@ -7918,6 +8088,20 @@ Projects (${creds.projects.length}):`);
     creds.projects.forEach((p) => console.log(`  ${p.id}  ${p.name}`));
   }
 });
+program2.command("profiles").description("List all configured credential profiles").action(async () => {
+  const all = await listAllProfiles();
+  const names = Object.keys(all);
+  if (names.length === 0) {
+    console.log("[ZeTa] No profiles configured. Run `zeta login`.");
+    return;
+  }
+  console.log("Configured profiles:");
+  names.forEach((name) => {
+    const c = all[name];
+    console.log(`  ${name.padEnd(12)} ${c.apiUrl}  (${c.workspaceName ?? c.workspaceId ?? "unknown"})`);
+  });
+  console.log("\nSwitch profiles with --profile <name> or ZETA_PROFILE=<name>");
+});
 program2.command("crawl").description("Trigger a crawl for a ZeTa project").requiredOption("-p, --project <id>", "ZeTa Project ID").option("-t, --token <token>", "ZeTa API Token (falls back to stored credentials)").option("-a, --api <url>", "ZeTa API URL (falls back to stored credentials)").option("-u, --url <url>", "App URL to crawl (overrides project setting)").option("--max-screens <n>", "Maximum screens to crawl", DEFAULT_MAX_SCREENS).option("--strategy <s>", "Traversal strategy: BFS | DFS | BEST_FIRST", DEFAULT_STRATEGY).option("--url-filter <regex>", "Regex \u2014 only crawl matching URLs").option("--no-wait", "Start crawl and exit without waiting for completion").action(async (options) => {
   const creds = await loadCreds();
   const token = options.token ?? creds?.token;
@@ -8117,8 +8301,11 @@ var LOG_FILE = (0, import_node_path2.join)(CREDS_DIR, "agent.log");
 function resolveZetaBinary() {
   return { node: process.execPath, script: process.argv[1] };
 }
-function getMacPlist(projectId) {
+function getMacPlist(projectId, profile) {
   const { node, script } = resolveZetaBinary();
+  const profileEntry = profile && profile !== "default" ? `
+        <key>ZETA_PROFILE</key>
+        <string>${profile}</string>` : "";
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -8145,13 +8332,15 @@ function getMacPlist(projectId) {
     <key>EnvironmentVariables</key>
     <dict>
         <key>PATH</key>
-        <string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin</string>
+        <string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin</string>${profileEntry}
     </dict>
 </dict>
 </plist>`;
 }
-function getLinuxUnit(projectId) {
+function getLinuxUnit(projectId, profile) {
   const { node, script } = resolveZetaBinary();
+  const profileEnv = profile && profile !== "default" ? `
+Environment=ZETA_PROFILE=${profile}` : "";
   return `[Unit]
 Description=ZeTa AI Local Agent (project ${projectId})
 After=network-online.target
@@ -8163,7 +8352,7 @@ ExecStart=${node} ${script} -p ${projectId}
 Restart=always
 RestartSec=10
 StandardOutput=append:${LOG_FILE}
-StandardError=append:${LOG_FILE}
+StandardError=append:${LOG_FILE}${profileEnv}
 
 [Install]
 WantedBy=default.target
@@ -8175,12 +8364,12 @@ async function getMacPlistPath() {
 function getLinuxUnitPath() {
   return (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".config", "systemd", "user", `${SERVICE_LABEL.replace(/\./g, "-")}.service`);
 }
-async function serviceInstall(projectId) {
+async function serviceInstall(projectId, profile) {
   if (process.platform === "darwin") {
     const plistPath = await getMacPlistPath();
     await (0, import_promises2.mkdir)((0, import_node_path2.join)((0, import_node_os2.homedir)(), "Library", "LaunchAgents"), { recursive: true });
     await (0, import_promises2.mkdir)(CREDS_DIR, { recursive: true });
-    await (0, import_promises2.writeFile)(plistPath, getMacPlist(projectId), { encoding: "utf-8", mode: 420 });
+    await (0, import_promises2.writeFile)(plistPath, getMacPlist(projectId, profile), { encoding: "utf-8", mode: 420 });
     await new Promise((resolve, reject) => {
       (0, import_node_child_process2.exec)(`launchctl unload "${plistPath}" 2>/dev/null; launchctl load -w "${plistPath}"`, (err) => {
         if (err)
@@ -8197,7 +8386,7 @@ async function serviceInstall(projectId) {
     const unitPath = getLinuxUnitPath();
     await (0, import_promises2.mkdir)((0, import_node_path2.join)((0, import_node_os2.homedir)(), ".config", "systemd", "user"), { recursive: true });
     await (0, import_promises2.mkdir)(CREDS_DIR, { recursive: true });
-    await (0, import_promises2.writeFile)(unitPath, getLinuxUnit(projectId), { encoding: "utf-8", mode: 420 });
+    await (0, import_promises2.writeFile)(unitPath, getLinuxUnit(projectId, profile), { encoding: "utf-8", mode: 420 });
     await new Promise((resolve, reject) => {
       (0, import_node_child_process2.exec)("systemctl --user daemon-reload", (err) => {
         if (err)
@@ -8306,12 +8495,13 @@ async function serviceStatus() {
   }
 }
 program2.command("service").description("Manage the ZeTa agent as a background system service").addCommand(
-  new Command("install").description("Install and start the agent as a service (auto-starts on login)").option("-p, --project <id>", "ZeTa Project ID (uses stored credentials if omitted)").action(async (opts) => {
-    const creds = await loadCreds();
+  new Command("install").description("Install and start the agent as a service (auto-starts on login)").option("-p, --project <id>", "ZeTa Project ID (uses stored credentials if omitted)").option("--profile <name>", 'Credential profile to use (default: $ZETA_PROFILE or "default")').action(async (opts) => {
+    const profile = resolveProfile(opts.profile);
+    const creds = await loadCreds(profile);
     let projectId = opts.project;
     if (!projectId) {
       if (!creds?.projects?.length) {
-        console.error("[ZeTa Service] No project ID. Run `zeta <api-key>` first, then `zeta service install -p <project-id>`");
+        console.error(`[ZeTa Service] No project ID. Run \`zeta <api-key> --profile ${profile}\` first, then \`zeta service install -p <project-id>\``);
         process.exit(1);
       }
       if (creds.projects.length === 1) {
@@ -8324,11 +8514,11 @@ program2.command("service").description("Manage the ZeTa agent as a background s
       }
     }
     if (!creds?.token) {
-      console.error("[ZeTa Service] No credentials. Run `zeta <api-key>` first.");
+      console.error(`[ZeTa Service] No credentials. Run \`zeta <api-key> --profile ${profile}\` first.`);
       process.exit(1);
     }
     try {
-      await serviceInstall(projectId);
+      await serviceInstall(projectId, profile);
     } catch (e) {
       console.error(`[ZeTa Service] Install failed: ${e instanceof Error ? e.message : String(e)}`);
       process.exitCode = 1;
@@ -8437,9 +8627,10 @@ program2.command("run_postman").description("Run a local Postman collection and
       process.exitCode = 1;
   }
 });
-program2.argument("[apiKey]", "API key from the ZeTa dashboard \u2014 saves credentials and exits (run `zeta -p <id>` afterwards)").option("-p, --project <id>", "ZeTa Project ID").option("-t, --token <token>", "ZeTa Agent Token (starts with zeta_)").option("-a, --api <url>", "ZeTa API base URL", process.env.ZETA_API_URL ?? "").action(async (apiKey, opts) => {
+program2.argument("[apiKey]", "API key from the ZeTa dashboard \u2014 saves credentials and exits (run `zeta -p <id>` afterwards)").option("-p, --project <id>", "ZeTa Project ID").option("-t, --token <token>", "ZeTa Agent Token (starts with zeta_)").option("-a, --api <url>", "ZeTa API base URL", process.env.ZETA_API_URL ?? "").option("--profile <name>", 'Credential profile to use/save (default: $ZETA_PROFILE or "default")').action(async (apiKey, opts) => {
+  const profile = resolveProfile(opts.profile);
   if (apiKey) {
-    const api2 = opts.api || API_URL;
+    const api2 = resolveApiUrl(opts.api || void 0, profile);
     const token2 = apiKey;
     console.log("[ZeTa] Validating token...");
     const headers = { Authorization: `Bearer ${token2}` };
@@ -8474,9 +8665,9 @@ program2.argument("[apiKey]", "API key from the ZeTa dashboard \u2014 saves cred
       }
     } catch {
     }
-    await saveCreds({ apiUrl: api2, token: token2, workspaceId, workspaceName, projects });
+    await saveCreds({ apiUrl: api2, token: token2, workspaceId, workspaceName, projects }, profile);
     console.log(`
-[ZeTa] \u2713 API key saved for "${workspaceName ?? workspaceId}"`);
+[ZeTa] \u2713 API key saved for "${workspaceName ?? workspaceId}" (profile: ${profile})`);
     console.log(`[ZeTa] Credentials stored: ${CREDS_FILE}`);
     if (projects.length > 0) {
       console.log(`
@@ -8486,16 +8677,16 @@ Projects (${projects.length}):`);
     const serviceProject = projects[0];
     if (serviceProject) {
       console.log(`
-[ZeTa] Installing background service for "${serviceProject.name}"...`);
+[ZeTa] Installing background service for "${serviceProject.name}" (profile: ${profile})...`);
       try {
-        await serviceInstall(serviceProject.id);
+        await serviceInstall(serviceProject.id, profile);
         if (projects.length > 1) {
           console.log(`[ZeTa] \u2139  Multiple projects found. Service running for "${serviceProject.name}".`);
           console.log(`[ZeTa]    To switch: zeta service uninstall && zeta service install -p <project-id>`);
         }
       } catch (e) {
         console.warn(`[ZeTa] \u26A0  Background service install failed: ${e instanceof Error ? e.message : String(e)}`);
-        console.warn(`[ZeTa]    Start manually: zeta -p ${serviceProject.id}`);
+        console.warn(`[ZeTa]    Start manually: zeta --profile ${profile} -p ${serviceProject.id}`);
       }
     } else {
       console.log(`
@@ -8504,13 +8695,13 @@ Projects (${projects.length}):`);
     }
     return;
   }
-  const creds = await loadCreds();
+  const creds = await loadCreds(profile);
   const token = opts.token ?? creds?.token;
-  const api = opts.api || creds?.apiUrl || API_URL;
+  const api = resolveApiUrl(opts.api || creds?.apiUrl || void 0, profile);
   const project = opts.project;
   if (!token) {
     console.error("[ZeTa Agent] No API key found.");
-    console.error("  Configure once: zeta <your-api-key>");
+    console.error(`  Configure once: zeta <your-api-key>${profile !== "default" ? ` --profile ${profile}` : ""}`);
     console.error("  Or pass inline: zeta -t <token> -p <project-id>");
     process.exit(1);
   }
@@ -8583,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
@@ -8595,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.");
@@ -8605,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());
@@ -8625,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}`;
@@ -8676,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;
       }
@@ -8723,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"] };