@xbrowser/cli 1.11.0 → 1.13.0

package/dist/index.js

@@ -25,7 +25,7 @@ import {
   forwardSessionList,
   forwardViewerCheckSelector,
   version
-} from "./chunk-WHPBNUKB.js";
+} from "./chunk-SH6OTPXN.js";
 import {
   buildViewerUrl
 } from "./chunk-3OD76SUE.js";
@@ -41,8 +41,9 @@ import {
   getMarketplaceUrl,
   loadConfig,
   resolveNpmPackageWithFallback,
+  resolveScreenshotsDir,
   setConfigValue
-} from "./chunk-DWDXEGVK.js";
+} from "./chunk-NKW4A74J.js";
 import {
   getDaemonConfig,
   getDaemonProcessStatus,
@@ -91,15 +92,17 @@ import {
   resolveLaunchOpts,
   saveSessionDiskMeta,
   setActivePage
-} from "./chunk-XKQVUFUS.js";
-import "./chunk-7OFM755Z.js";
+} from "./chunk-CW7L53JE.js";
+import "./chunk-R2POF2GP.js";
 import "./chunk-TNEN6VQ2.js";
 import {
   errMsg
 } from "./chunk-GDKLH7ZY.js";
 import {
   CDPInterceptorProxy,
-  advise,
+  advise
+} from "./chunk-A6LPGFAL.js";
+import {
   automationSignalsRule,
   createRuleEngine,
   domMutationRule,
@@ -110,15 +113,15 @@ import {
   mouseTrajectoryRule,
   networkAnomalyRule,
   pageLifecycleRule
-} from "./chunk-ABXMBNQ6.js";
+} from "./chunk-H2A5JUK5.js";
 import {
   __require
 } from "./chunk-KFQGP6VL.js";
 
 // src/executor.ts
 import {
-  ok as ok25,
-  fail as fail11,
+  ok as ok28,
+  fail as fail13,
   isCommandResult,
   CompositeStorage as CompositeStorage2,
   TipCollector as TipCollector2,
@@ -994,29 +997,441 @@ var mouseCommand = registerCommand({
   }
 });
 
-// src/commands/evaluate.ts
+// src/commands/find-visual.ts
 import { z as z7 } from "zod";
-import { ok as ok7, normalizeTips as normalizeTips2 } from "@dyyz1993/xcli-core";
+import { ok as ok7, fail as fail2 } from "@dyyz1993/xcli-core";
+import { readFileSync, existsSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+function loadVLMCredentials() {
+  const candidates = [
+    process.env.XBROWSER_VLM_CONFIG,
+    join2(homedir2(), ".zcode", "v2", "config.json")
+  ].filter(Boolean);
+  for (const file of candidates) {
+    try {
+      if (!existsSync(file)) continue;
+      const cfg = JSON.parse(readFileSync(file, "utf8"));
+      const provider = Object.values(cfg.provider ?? {})[0];
+      if (provider?.options?.apiKey && provider.options.baseURL) {
+        const models = Object.keys(provider.models ?? {});
+        const vl = models.find((m) => /vl|vision/i.test(m));
+        const flash = models.find((m) => /flash/i.test(m) && /5\.?3/i.test(m));
+        return {
+          apiKey: provider.options.apiKey,
+          baseURL: provider.options.baseURL.replace(/\/$/, ""),
+          model: process.env.XBROWSER_VLM_MODEL || vl || flash || models.find((m) => /5\.[23]/.test(m)) || models[0]
+        };
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function locateByVLM(creds, imageBase64, target, feedback) {
+  const prompt = `\u4F60\u5728\u4E00\u5F20\u7F51\u9875\u622A\u56FE\u4E0A\u5B9A\u4F4D UI \u5143\u7D20\u3002\u76EE\u6807\u5143\u7D20\u63CF\u8FF0\uFF1A"""${target}"""
+
+\u4E25\u683C\u53EA\u8F93\u51FA\u4E00\u4E2A JSON \u5BF9\u8C61\uFF08\u65E0 markdown\u3001\u65E0\u89E3\u91CA\uFF09\uFF1A
+{"label":"<\u5143\u7D20\u540D>","box":{"x":<\u5DE6\u4E0Ax>,"y":<\u5DE6\u4E0Ay>,"width":<\u5BBD>,"height":<\u9AD8>},"confidence":"high|medium|low"}
+\u5750\u6807\u4EE5\u622A\u56FE\u5DE6\u4E0A\u89D2\u4E3A\u539F\u70B9\u3001\u5355\u4F4D\u4E3A\u50CF\u7D20\u3002\u627E\u4E0D\u5230\u5143\u7D20\u5219\u8F93\u51FA {"label":null}\u3002
+${feedback ? `\u6CE8\u610F\uFF1A${feedback}` : ""}`;
+  const resp = await fetch(creds.baseURL + "/v1/messages", {
+    method: "POST",
+    headers: { "content-type": "application/json", "x-api-key": creds.apiKey, "anthropic-version": "2023-06-01" },
+    body: JSON.stringify({
+      model: creds.model,
+      max_tokens: 2e3,
+      // thinking 模型的思考块也计入配额，300 会在 text 前截断
+      messages: [{
+        role: "user",
+        content: [
+          { type: "image", source: { type: "base64", media_type: "image/png", data: imageBase64 } },
+          { type: "text", text: prompt }
+        ]
+      }]
+    }),
+    signal: AbortSignal.timeout(6e4)
+  });
+  if (!resp.ok) throw new Error(`VLM HTTP ${resp.status}`);
+  const data = await resp.json();
+  const text = (data.content ?? []).filter((c) => c.type === "text").map((c) => c.text ?? "").join("");
+  const m = text.match(/\{[\s\S]*\}/);
+  if (!m) {
+    console.error("[find-visual] VLM raw (no JSON):", text.substring(0, 200));
+    return null;
+  }
+  const hit = JSON.parse(m[0]);
+  if (!hit.label || !hit.box) return null;
+  return hit;
+}
+var findVisualCommand = registerCommand({
+  name: "find-visual",
+  description: "Visual element location: screenshot \u2192 VLM \u2192 page coordinates (optionally click)",
+  scope: "page",
+  parameters: z7.object({
+    element: z7.string().describe('\u5143\u7D20\u7684\u81EA\u7136\u8BED\u8A00\u63CF\u8FF0\uFF0C\u5982 "\u7EA2\u8272\u7684\u767B\u5F55\u6309\u94AE"\uFF08\u6CE8\u610F\uFF1A--target \u662F\u5168\u5C40\u9875\u9762\u8DEF\u7531\u53C2\u6570\uFF0C\u6B64\u5904\u7528 --element\uFF09'),
+    click: z7.boolean().optional().describe("\u627E\u5230\u540E\u7ACB\u5373\u70B9\u51FB\uFF08\u771F\u5B9E\u9F20\u6807\u4E8B\u4EF6\uFF09"),
+    threshold: z7.coerce.number().optional().describe("\u7F6E\u4FE1\u5EA6\u9608\u503C\uFF0C\u4F4E\u4E8E\u5219\u62A5 not-found\uFF08\u9ED8\u8BA4 0\uFF09"),
+    zoom: z7.boolean().optional().describe("\u4E8C\u6BB5\u5F0F\u653E\u5927\u7CBE\u4FEE\uFF08\u9ED8\u8BA4\u5F00\uFF09\u2014\u2014\u7C97\u6846\u533A\u57DF\u4E8C\u6B21\u622A\u56FE\u8BA9 VLM \u7CBE\u786E\u5B9A\u4F4D")
+  }),
+  result: z7.object({
+    found: z7.boolean(),
+    element: z7.string(),
+    box: z7.unknown().optional(),
+    center: z7.unknown().optional(),
+    confidence: z7.string().optional(),
+    model: z7.string().optional(),
+    clicked: z7.boolean().optional(),
+    screenshot: z7.string().optional()
+  }),
+  handler: async (p, ctx) => {
+    const page = ctx.page;
+    const creds = loadVLMCredentials();
+    if (!creds) {
+      return fail2("\u672A\u627E\u5230 VLM \u51ED\u636E\uFF1A\u9700\u8981 ~/.zcode/v2/config.json \u7684 provider \u914D\u7F6E\u6216 XBROWSER_VLM_CONFIG \u73AF\u5883\u53D8\u91CF", [
+        "\u4E5F\u53EF\u7528 XBROWSER_VLM_MODEL \u6307\u5B9A\u6A21\u578B\uFF08\u9ED8\u8BA4\u81EA\u52A8\u9009 VL/\u65D7\u8230\u6A21\u578B\uFF09"
+      ]);
+    }
+    const buffer = await page.screenshot({ type: "png" });
+    const imageBase64 = buffer.toString("base64");
+    const imgW = buffer.readUInt32BE(16);
+    const imgH = buffer.readUInt32BE(20);
+    let hit = null;
+    let feedback = "";
+    try {
+      for (let attempt = 0; attempt < 3 && !hit; attempt++) {
+        const candidate = await locateByVLM(creds, imageBase64, p.element, feedback);
+        if (!candidate) break;
+        const b = candidate.box;
+        const inBounds = b.x >= 0 && b.y >= 0 && b.x + b.width <= imgW + 2 && b.y + b.height <= imgH + 2;
+        const sane = b.width > 2 && b.height > 2;
+        if (inBounds && sane) {
+          hit = candidate;
+          break;
+        }
+        feedback = `\u4E0A\u6B21\u8F93\u51FA box=${JSON.stringify(b)} \u65E0\u6548\uFF08${!inBounds ? "\u8D85\u51FA\u56FE\u50CF\u8FB9\u754C" : "\u5C3A\u5BF8\u8FC7\u5C0F"}\uFF09\u3002\u8BF7\u57FA\u4E8E\u622A\u56FE\u91CD\u65B0\u4ED4\u7EC6\u5B9A\u4F4D\uFF0C\u5750\u6807\u539F\u70B9\u5728\u56FE\u50CF\u5DE6\u4E0A\u89D2\u3002`;
+      }
+    } catch (e) {
+      return fail2(`VLM \u8C03\u7528\u5931\u8D25: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    if (!hit) {
+      return ok7({ found: false, element: p.element, model: creds.model }, [
+        `\u622A\u56FE\u4E2D\u672A\u627E\u5230: ${p.element}`
+      ]);
+    }
+    if (p.zoom !== false && hit) {
+      try {
+        const pad = Math.max(20, Math.round(Math.max(hit.box.width, hit.box.height) * 0.5));
+        const clip = {
+          x: Math.max(0, hit.box.x - pad),
+          y: Math.max(0, hit.box.y - pad),
+          width: Math.min(imgW - Math.max(0, hit.box.x - pad), hit.box.width + pad * 2),
+          height: Math.min(imgH - Math.max(0, hit.box.y - pad), hit.box.height + pad * 2)
+        };
+        if (clip.width > 8 && clip.height > 8) {
+          const zoomBuf = await page.screenshot({ type: "png", clip });
+          const zoomB64 = zoomBuf.toString("base64");
+          const zoomW = zoomBuf.readUInt32BE(16);
+          const zoomH = zoomBuf.readUInt32BE(20);
+          const refined = await locateByVLM(creds, zoomB64, p.element);
+          if (refined) {
+            const rb = refined.box;
+            const inZoom = rb.x >= 0 && rb.y >= 0 && rb.x + rb.width <= zoomW + 2 && rb.y + rb.height <= zoomH + 2 && rb.width > 2 && rb.height > 2;
+            if (inZoom) {
+              hit = {
+                label: refined.label || hit.label,
+                box: {
+                  x: clip.x + rb.x,
+                  y: clip.y + rb.y,
+                  width: rb.width,
+                  height: rb.height
+                },
+                confidence: refined.confidence === "low" ? hit.confidence : refined.confidence
+              };
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    if (p.threshold !== void 0) {
+      const rank = { high: 3, medium: 2, low: 1 };
+      const thresholdName = p.threshold >= 3 ? "high" : p.threshold >= 2 ? "medium" : "low";
+      if ((rank[hit.confidence ?? "low"] ?? 1) < (rank[thresholdName] ?? 1)) {
+        return ok7({ found: false, element: p.element, confidence: hit.confidence, box: hit.box, model: creds.model }, [
+          `\u7F6E\u4FE1\u5EA6 ${hit.confidence} \u4F4E\u4E8E\u9608\u503C ${p.threshold}`
+        ]);
+      }
+    }
+    const viewport = await page.evaluate("JSON.stringify({w: window.innerWidth, h: window.innerHeight})").then((v) => JSON.parse(String(v))).catch(() => ({ w: 1280, h: 800 }));
+    const pngW = buffer.readUInt32BE(16);
+    const pngH = buffer.readUInt32BE(20);
+    const scaleX = viewport.w / pngW;
+    const scaleY = viewport.h / pngH;
+    const center = {
+      x: Math.round((hit.box.x + hit.box.width / 2) * scaleX),
+      y: Math.round((hit.box.y + hit.box.height / 2) * scaleY)
+    };
+    let clicked = false;
+    if (p.click) {
+      await page.mouse.click(center.x, center.y, { stealth: true });
+      clicked = true;
+    }
+    return ok7({
+      found: true,
+      element: p.element,
+      box: hit.box,
+      center,
+      confidence: hit.confidence,
+      model: creds.model,
+      clicked,
+      screenshot: `data:image/png;base64,${imageBase64.substring(0, 64)}... (${Math.round(imageBase64.length / 1024)}KB)`
+    }, [
+      clicked ? `\u5DF2\u70B9\u51FB (${center.x}, ${center.y}) \u2014 ${hit.label} [${hit.confidence}]` : `\u5B9A\u4F4D\u5230 "${hit.label}" \u4E2D\u5FC3 (${center.x}, ${center.y}) [${hit.confidence}] \u2014 \u52A0 --click \u6267\u884C\u70B9\u51FB`
+    ]);
+  }
+});
+
+// src/commands/vision-task.ts
+import { z as z8 } from "zod";
+import { ok as ok8, fail as fail3 } from "@dyyz1993/xcli-core";
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+function loadVLMCredentials2() {
+  const candidates = [
+    process.env.XBROWSER_VLM_CONFIG,
+    join3(homedir3(), ".zcode", "v2", "config.json")
+  ].filter(Boolean);
+  for (const file of candidates) {
+    try {
+      if (!existsSync2(file)) continue;
+      const cfg = JSON.parse(readFileSync2(file, "utf8"));
+      const provider = Object.values(cfg.provider ?? {})[0];
+      if (provider?.options?.apiKey && provider.options.baseURL) {
+        const models = Object.keys(provider.models ?? {});
+        const vl = models.find((m) => /vl|vision/i.test(m));
+        const flash = models.find((m) => /flash/i.test(m) && /5\.?3/i.test(m));
+        return {
+          apiKey: provider.options.apiKey,
+          baseURL: provider.options.baseURL.replace(/\/$/, ""),
+          model: process.env.XBROWSER_VLM_MODEL || vl || flash || models.find((m) => /5\.[23]/.test(m)) || models[0]
+        };
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function vlmAsk(creds, content, maxTokens = 2e3) {
+  const resp = await fetch(creds.baseURL + "/v1/messages", {
+    method: "POST",
+    headers: { "content-type": "application/json", "x-api-key": creds.apiKey, "anthropic-version": "2023-06-01" },
+    body: JSON.stringify({ model: creds.model, max_tokens: maxTokens, messages: [{ role: "user", content }] }),
+    signal: AbortSignal.timeout(9e4)
+  });
+  if (!resp.ok) throw new Error(`VLM HTTP ${resp.status}`);
+  const data = await resp.json();
+  return (data.content ?? []).filter((c) => c.type === "text").map((c) => c.text ?? "").join("");
+}
+async function vlmAskRetry(creds, content, maxTokens = 2e3) {
+  let last = "";
+  for (let i = 0; i < 2; i++) {
+    last = await vlmAsk(creds, content, maxTokens);
+    if (last.trim()) return last;
+    await new Promise((r) => setTimeout(r, 1200));
+  }
+  return last;
+}
+function pngDims(b64) {
+  const buf = Buffer.from(b64, "base64");
+  return { w: buf.readUInt32BE(16), h: buf.readUInt32BE(20) };
+}
+function parseDecision(text) {
+  const m = text.match(/\{[\s\S]*\}/);
+  if (!m) return null;
+  try {
+    const j = JSON.parse(m[0]);
+    if (!j.action || !j.action.type) return null;
+    return j;
+  } catch {
+    return null;
+  }
+}
+var SYSTEM_PROMPT = `\u4F60\u662F\u6D4F\u89C8\u5668\u89C6\u89C9\u64CD\u4F5C Agent\u3002\u6839\u636E\u622A\u56FE\u548C\u4EFB\u52A1\u5386\u53F2\uFF0C\u51B3\u5B9A\u4E0B\u4E00\u4E2A\u52A8\u4F5C\u3002
+
+\u4E25\u683C\u53EA\u8F93\u51FA\u4E00\u4E2A JSON\uFF08\u65E0 markdown\uFF09\uFF1A
+{"thought":"<\u7B80\u77ED\u63A8\u7406>","action":{"type":"click","x":<int>,"y":<int>}
+  \u6216 {"type":"type","text":"<\u8981\u8F93\u5165\u7684\u6587\u5B57>"}\uFF08\u8F93\u5165\u524D\u987B\u5DF2\u70B9\u51FB\u805A\u7126\u8F93\u5165\u6846\uFF09
+  \u6216 {"type":"key","key":"Enter"}\uFF08key \u540D\uFF1AEnter/Tab/Escape/ArrowDown\u2026\uFF09
+  \u6216 {"type":"scroll","direction":"down","amount":<px>}
+  \u6216 {"type":"done","summary":"<\u4EFB\u52A1\u5B8C\u6210\u6458\u8981>"}
+  \u6216 {"type":"stuck","reason":"<\u65E0\u6CD5\u7EE7\u7EED\u7684\u539F\u56E0>"}}
+
+\u5750\u6807\u4EE5\u622A\u56FE\u5DE6\u4E0A\u89D2\u4E3A\u539F\u70B9\u3001\u50CF\u7D20\u4E3A\u5355\u4F4D\u3002\u89C4\u5219\uFF1A
+1. \u6BCF\u6B21\u53EA\u505A\u4E00\u4E2A\u52A8\u4F5C\uFF1B\u8F93\u5165\u6587\u5B57\u524D\u786E\u8BA4\u8F93\u5165\u6846\u5DF2\u805A\u7126\uFF08\u4E0A\u4E00\u6B65\u662F click \u8F93\u5165\u6846\uFF09
+2. \u9875\u9762\u65E0\u660E\u663E\u53D8\u5316\u65F6\u6362\u7B56\u7565\uFF0C\u4E0D\u8981\u91CD\u590D\u540C\u4E00\u52A8\u4F5C\u8D85\u8FC7 2 \u6B21
+3. \u4EFB\u52A1\u76EE\u6807\u8FBE\u6210\u7ACB\u5373\u8F93\u51FA done\uFF1B5 \u6B65\u65E0\u8FDB\u5C55\u8F93\u51FA stuck`;
+var visionTaskCommand = registerCommand({
+  name: "vision-task",
+  description: "Vision-loop agent: screenshot \u2192 VLM decide \u2192 CDP act \u2192 verify, until done",
+  scope: "page",
+  parameters: z8.object({
+    task: z8.string().describe('\u81EA\u7136\u8BED\u8A00\u4EFB\u52A1\uFF0C\u5982 "\u641C\u7D22 xbrowser \u5E76\u6253\u5F00\u7B2C\u4E00\u7BC7\u6587\u7AE0"'),
+    maxSteps: z8.coerce.number().optional().describe("\u6700\u5927\u6B65\u6570\uFF08\u9ED8\u8BA4 12\uFF09"),
+    settleMs: z8.coerce.number().optional().describe("\u6BCF\u6B65\u540E\u7B49\u5F85\u9875\u9762\u7A33\u5B9A\u7684\u6BEB\u79D2\u6570\uFF08\u9ED8\u8BA4 1500\uFF09")
+  }),
+  result: z8.object({
+    done: z8.boolean(),
+    steps: z8.unknown().optional(),
+    summary: z8.string().optional(),
+    model: z8.string().optional()
+  }),
+  handler: async (p, ctx) => {
+    let page = ctx.page;
+    const creds = loadVLMCredentials2();
+    if (!creds) {
+      return fail3("\u672A\u627E\u5230 VLM \u51ED\u636E\uFF1A\u9700\u8981 ~/.zcode/v2/config.json \u6216 XBROWSER_VLM_CONFIG");
+    }
+    const maxSteps = p.maxSteps ?? 12;
+    const settleMs = p.settleMs ?? 1500;
+    const steps = [];
+    const history = [];
+    let lastUrl = page.url();
+    for (let step = 1; step <= maxSteps; step++) {
+      if (page.url() === "about:blank") {
+        try {
+          const ctxObj = page.context?.();
+          const pages = ctxObj?.pages?.() || [];
+          let real;
+          for (let i = pages.length - 1; i >= 0; i--) {
+            const u = pages[i]?.url?.() ?? "";
+            if (u && u !== "about:blank") {
+              real = pages[i];
+              break;
+            }
+          }
+          if (real) {
+            await real.bringToFront().catch(() => {
+            });
+            page = real;
+          }
+        } catch {
+        }
+      }
+      const buffer = await page.screenshot({ type: "png" });
+      const b64 = buffer.toString("base64");
+      const { w, h } = pngDims(b64);
+      const obsText = [
+        `\u4EFB\u52A1\uFF1A${p.task}`,
+        `\u622A\u56FE\u5C3A\u5BF8\uFF1A${w}x${h}\uFF08\u5750\u6807\u539F\u70B9\uFF1A\u5DE6\u4E0A\u89D2\uFF09`,
+        `\u5F53\u524D URL\uFF1A${page.url()}`,
+        history.length ? `\u5DF2\u6267\u884C\u52A8\u4F5C\uFF1A
+${history.slice(-6).join("\n")}` : "\u5C1A\u65E0\u52A8\u4F5C\u3002"
+      ].join("\n");
+      const reply = await vlmAskRetry(creds, [
+        { type: "image", source: { type: "base64", media_type: "image/png", data: b64 } },
+        { type: "text", text: `${SYSTEM_PROMPT}
+
+${obsText}` }
+      ]);
+      const decision = parseDecision(reply);
+      if (!decision) {
+        steps.push({ n: step, thought: "(unparseable)", action: "stop", ts: Date.now() });
+        return ok8({ done: false, steps, summary: `\u7B2C ${step} \u6B65 VLM \u8F93\u51FA\u65E0\u6CD5\u89E3\u6790: ${reply.substring(0, 120)}`, model: creds.model });
+      }
+      const a = decision.action;
+      let acted = "";
+      try {
+        if (a.type === "done") {
+          steps.push({ n: step, thought: decision.thought, action: "done", ts: Date.now() });
+          return ok8({ done: true, steps, summary: a.summary, model: creds.model });
+        }
+        if (a.type === "stuck") {
+          steps.push({ n: step, thought: decision.thought, action: "stuck", ts: Date.now() });
+          return ok8({ done: false, steps, summary: `stuck: ${a.reason}`, model: creds.model });
+        }
+        if (a.type === "click") {
+          const cx = Math.max(2, Math.min(w - 2, Math.round(a.x)));
+          const cy = Math.max(2, Math.min(h - 2, Math.round(a.y)));
+          await page.mouse.click(cx, cy, { stealth: true });
+          acted = `click(${cx},${cy})`;
+        } else if (a.type === "type") {
+          await page.keyboard.type(a.text, { stealth: true });
+          acted = `type("${a.text.substring(0, 30)}")`;
+        } else if (a.type === "key") {
+          await page.keyboard.press(a.key);
+          acted = `key(${a.key})`;
+        } else if (a.type === "scroll") {
+          await page.mouse.wheel(0, a.direction === "down" ? a.amount : -a.amount);
+          acted = `scroll(${a.direction},${a.amount})`;
+        }
+      } catch (e) {
+        acted = `${a.type} FAILED: ${e instanceof Error ? e.message : String(e).substring(0, 80)}`;
+      }
+      steps.push({ n: step, thought: decision.thought, action: acted, ts: Date.now() });
+      history.push(`${step}. ${acted} \u2014 ${decision.thought.substring(0, 60)}`);
+      await new Promise((r) => setTimeout(r, settleMs));
+      if (a.type === "click") {
+        try {
+          const ctxObj = page.context?.();
+          const pages = ctxObj?.pages?.() || [];
+          for (let i = pages.length - 1; i >= 0; i--) {
+            const cand = pages[i];
+            if (!cand || cand === page) continue;
+            const u = cand.url?.() ?? "";
+            if (!u || u === "about:blank") continue;
+            if (u === page.url()) break;
+            await cand.bringToFront().catch(() => {
+            });
+            page = cand;
+            break;
+          }
+        } catch {
+        }
+      }
+      const urlNow = page.url();
+      if (urlNow !== lastUrl) {
+        history.push(`   [\u9875\u9762\u8DF3\u8F6C \u2192 ${urlNow.substring(0, 80)}]`);
+        lastUrl = urlNow;
+      }
+    }
+    return ok8({ done: false, steps, summary: `\u5DF2\u8FBE\u6700\u5927\u6B65\u6570 ${maxSteps}`, model: creds.model });
+  }
+});
+
+// src/commands/evaluate.ts
+import { z as z9 } from "zod";
+import { ok as ok9, normalizeTips as normalizeTips2 } from "@dyyz1993/xcli-core";
 var evaluateCommand = registerCommand({
   name: "eval",
   description: "Evaluate JavaScript expression in the browser (--frame <url-substring> \u53EF\u5B9A\u5411\u5230 iframe \u4E0A\u4E0B\u6587\uFF0C\u8DE8\u57DF iframe \u4EA6\u53EF)",
   scope: "page",
-  parameters: z7.object({
-    expression: z7.string(),
-    frame: z7.string().optional().describe("\u5728 URL \u542B\u6B64\u5B50\u4E32\u7684 iframe \u91CC\u6267\u884C\uFF08\u540C\u8FDB\u7A0B\u7528 contextId\uFF0C\u8DE8\u57DF OOPIF \u7528 Target auto-attach\uFF09")
+  parameters: z9.object({
+    expression: z9.string().optional(),
+    frame: z9.string().optional().describe("\u5728 URL \u542B\u6B64\u5B50\u4E32\u7684 iframe \u91CC\u6267\u884C\uFF08\u540C\u8FDB\u7A0B\u7528 contextId\uFF0C\u8DE8\u57DF OOPIF \u7528 Target auto-attach\uFF09"),
+    // Internal: base64url-encoded script set by the router for `eval <js...>`,
+    // so multiline/semicolon JS survives chain parsing (which splits on ';'
+    // and whitespace). Not intended for direct CLI use.
+    "script-b64": z9.string().optional().describe("Internal: base64url script set by the CLI router; do not pass directly")
   }),
   handler: async (p, ctx) => {
+    const rawScript = p["script-b64"];
+    const expression = rawScript ? Buffer.from(rawScript, "base64url").toString("utf8") : p.expression;
+    if (!expression || !expression.trim()) {
+      return { ok: false, error: "eval: expression is required" };
+    }
     const engine = createRuleEngine();
     engine.start();
     const decision = engine.evaluate({
       method: "Runtime.evaluate",
-      params: { expression: p.expression },
+      params: { expression },
       sessionId: "eval-check",
       direction: "client\u2192browser"
     });
     engine.stop();
-    const result = p.frame ? await ctx.page.evaluateInFrame(p.frame, p.expression) : await ctx.page.evaluate(p.expression);
-    const response = ok7({ result });
+    const result = p.frame ? await ctx.page.evaluateInFrame(p.frame, expression) : await ctx.page.evaluate(expression);
+    const response = ok9({ result });
     if (decision && decision.severity === "danger") {
       response.tips = normalizeTips2([`${decision.suggestion}`]);
     }
@@ -1024,37 +1439,65 @@ var evaluateCommand = registerCommand({
   }
 });
 
+// src/commands/ua.ts
+import { z as z10 } from "zod";
+import { ok as ok10 } from "@dyyz1993/xcli-core";
+function uaHookScript(ua) {
+  const uaJson = JSON.stringify(ua);
+  const appVersion = JSON.stringify(ua.replace(/^Mozilla\//, ""));
+  return `try{Object.defineProperty(navigator,'userAgent',{get:()=>${uaJson},configurable:true});Object.defineProperty(navigator,'appVersion',{get:()=>${appVersion},configurable:true});Object.defineProperty(navigator,'vendor',{get:()=>'Google Inc.',configurable:true});}catch(e){}`;
+}
+var uaCommand = registerCommand({
+  name: "ua",
+  description: "Get or override the session User-Agent (anti-bot UA detection countermeasure)",
+  scope: "page",
+  parameters: z10.object({
+    value: z10.string().optional().describe('\u65B0\u7684 User-Agent\uFF1B\u7559\u7A7A\u5219\u8FD4\u56DE\u5F53\u524D UA\uFF1B"reset" \u6062\u590D\u5E38\u89C1 Chrome UA')
+  }),
+  handler: async (p, ctx) => {
+    if (!p.value) {
+      const current = await ctx.page.evaluate("navigator.userAgent");
+      return ok10({ userAgent: current });
+    }
+    const ua = p.value.toLowerCase() === "reset" ? "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36" : p.value;
+    const script = uaHookScript(ua);
+    await ctx.page.addInitScript(script);
+    await ctx.page.evaluate(`(function(){${script}})()`);
+    return ok10({ userAgent: ua, mode: "init-script" });
+  }
+});
+
 // src/commands/storage.ts
-import { z as z8 } from "zod";
-import { ok as ok8, fail as fail2 } from "@dyyz1993/xcli-core";
+import { z as z11 } from "zod";
+import { ok as ok11, fail as fail4 } from "@dyyz1993/xcli-core";
 var getCookiesCommand = registerCommand({
   name: "get-cookies",
   description: "Get all cookies for the current page",
   scope: "page",
-  result: z8.object({
-    cookies: z8.array(z8.record(z8.unknown()))
+  result: z11.object({
+    cookies: z11.array(z11.record(z11.unknown()))
   }),
   handler: async (_p, ctx) => {
     const cookies = await ctx.browserContext.cookies();
-    return ok8({ cookies });
+    return ok11({ cookies });
   }
 });
 var setCookieCommand = registerCommand({
   name: "set-cookie",
   description: "Set a cookie",
   scope: "page",
-  parameters: z8.object({
-    name: z8.coerce.string(),
-    value: z8.coerce.string(),
-    domain: z8.coerce.string().optional(),
-    path: z8.coerce.string().optional(),
-    url: z8.string().optional().describe("Cookie URL (alternative to domain)"),
-    expires: z8.number().optional(),
-    httpOnly: z8.boolean().optional(),
-    secure: z8.boolean().optional(),
-    sameSite: z8.enum(["Strict", "Lax", "None"]).optional()
+  parameters: z11.object({
+    name: z11.coerce.string(),
+    value: z11.coerce.string(),
+    domain: z11.coerce.string().optional(),
+    path: z11.coerce.string().optional(),
+    url: z11.string().optional().describe("Cookie URL (alternative to domain)"),
+    expires: z11.number().optional(),
+    httpOnly: z11.boolean().optional(),
+    secure: z11.boolean().optional(),
+    sameSite: z11.enum(["Strict", "Lax", "None"]).optional()
   }),
-  result: z8.object({ name: z8.string() }),
+  result: z11.object({ name: z11.string() }),
   handler: async (p, ctx) => {
     const cookie = { ...p };
     if (!cookie.domain && !cookie.url) {
@@ -1069,38 +1512,38 @@ var setCookieCommand = registerCommand({
       }
     }
     if (!cookie.domain && !cookie.url) {
-      return fail2("set-cookie requires --domain or --url, or a non-blank page URL to infer from");
+      return fail4("set-cookie requires --domain or --url, or a non-blank page URL to infer from");
     }
     await ctx.browserContext.addCookies([cookie]);
-    return ok8({ name: p.name });
+    return ok11({ name: p.name });
   }
 });
 var clearCookiesCommand = registerCommand({
   name: "clear-cookies",
   description: "Clear all cookies",
   scope: "page",
-  result: z8.object({ cleared: z8.boolean() }),
+  result: z11.object({ cleared: z11.boolean() }),
   handler: async (_p, ctx) => {
     await ctx.browserContext.clearCookies();
-    return ok8({ cleared: true });
+    return ok11({ cleared: true });
   }
 });
 var getLocalStorageCommand = registerCommand({
   name: "get-local-storage",
   description: "Get localStorage entries",
   scope: "page",
-  parameters: z8.object({
-    key: z8.string().optional()
+  parameters: z11.object({
+    key: z11.string().optional()
   }),
-  result: z8.union([
-    z8.object({ key: z8.string(), value: z8.string().nullable() }),
-    z8.object({ data: z8.record(z8.string()) })
+  result: z11.union([
+    z11.object({ key: z11.string(), value: z11.string().nullable() }),
+    z11.object({ data: z11.record(z11.string()) })
   ]),
   handler: async (p, ctx) => {
     try {
       if (p.key) {
         const value = await ctx.page.evaluate((k) => localStorage.getItem(k), p.key);
-        return ok8({ key: p.key, value });
+        return ok11({ key: p.key, value });
       }
       const data = await ctx.page.evaluate(() => {
         const entries = {};
@@ -1110,9 +1553,9 @@ var getLocalStorageCommand = registerCommand({
         }
         return entries;
       });
-      return ok8({ data });
+      return ok11({ data });
     } catch (e) {
-      return fail2(`localStorage not accessible on this page: ${e instanceof Error ? e.message : String(e)}`);
+      return fail4(`localStorage not accessible on this page: ${e instanceof Error ? e.message : String(e)}`);
     }
   }
 });
@@ -1120,11 +1563,11 @@ var setLocalStorageCommand = registerCommand({
   name: "set-local-storage",
   description: "Set a localStorage entry",
   scope: "page",
-  parameters: z8.object({
-    key: z8.string(),
-    value: z8.string()
+  parameters: z11.object({
+    key: z11.string(),
+    value: z11.string()
   }),
-  result: z8.object({ key: z8.string() }),
+  result: z11.object({ key: z11.string() }),
   handler: async (p, ctx) => {
     try {
       await ctx.page.evaluate(
@@ -1133,9 +1576,9 @@ var setLocalStorageCommand = registerCommand({
         },
         { key: p.key, value: p.value }
       );
-      return ok8({ key: p.key });
+      return ok11({ key: p.key });
     } catch (e) {
-      return fail2(`localStorage not accessible on this page: ${e instanceof Error ? e.message : String(e)}`);
+      return fail4(`localStorage not accessible on this page: ${e instanceof Error ? e.message : String(e)}`);
     }
   }
 });
@@ -1143,26 +1586,24 @@ var clearLocalStorageCommand = registerCommand({
   name: "clear-local-storage",
   description: "Clear all localStorage entries",
   scope: "page",
-  result: z8.object({ cleared: z8.boolean() }),
+  result: z11.object({ cleared: z11.boolean() }),
   handler: async (_p, ctx) => {
     try {
       await ctx.page.evaluate(() => localStorage.clear());
-      return ok8({ cleared: true });
+      return ok11({ cleared: true });
     } catch (e) {
-      return fail2(`localStorage not accessible on this page: ${e instanceof Error ? e.message : String(e)}`);
+      return fail4(`localStorage not accessible on this page: ${e instanceof Error ? e.message : String(e)}`);
     }
   }
 });
 
 // src/commands/screenshot.ts
-import { z as z9 } from "zod";
-import { ok as ok9, fail as fail3 } from "@dyyz1993/xcli-core";
+import { z as z12 } from "zod";
+import { ok as ok12, fail as fail5 } from "@dyyz1993/xcli-core";
 import { writeFileSync, mkdirSync } from "fs";
-import { dirname, join as join2 } from "path";
-import { homedir as homedir2 } from "os";
-var SCREENSHOTS_DIR = join2(homedir2(), ".xbrowser", "screenshots");
+import { dirname, join as join4 } from "path";
 function ensureScreenshotsDir() {
-  mkdirSync(SCREENSHOTS_DIR, { recursive: true });
+  mkdirSync(resolveScreenshotsDir(), { recursive: true });
 }
 function ensureParentDir(filePath) {
   const dir = dirname(filePath);
@@ -1178,30 +1619,30 @@ function generateScreenshotPath(format) {
   const timestamp = Date.now();
   const random = Math.random().toString(36).slice(2, 8);
   const ext = format === "jpeg" ? "jpg" : "png";
-  return join2(SCREENSHOTS_DIR, `screenshot-${timestamp}-${random}.${ext}`);
+  return join4(resolveScreenshotsDir(), `screenshot-${timestamp}-${random}.${ext}`);
 }
 var screenshotCommand = registerCommand({
   name: "screenshot",
-  description: "Take a screenshot of the page or element",
+  description: "Take a screenshot of the page or element (auto-saved to the OS temp dir unless --output is given; persistent override: xbrowser config set screenshots.dir <path>)",
   scope: "page",
   selectorParams: ["selector"],
-  parameters: z9.object({
-    selector: z9.string().optional(),
-    type: z9.enum(["png", "jpeg"]).optional(),
-    fullPage: z9.boolean().optional(),
-    output: z9.string().optional(),
-    base64: z9.boolean().optional().describe("Return base64 data instead of file path")
+  parameters: z12.object({
+    selector: z12.string().optional(),
+    type: z12.enum(["png", "jpeg"]).optional(),
+    fullPage: z12.boolean().optional(),
+    output: z12.string().optional(),
+    base64: z12.boolean().optional().describe("Return base64 data instead of file path")
   }),
-  result: z9.union([
-    z9.object({
-      data: z9.string(),
-      format: z9.string(),
-      size: z9.number()
+  result: z12.union([
+    z12.object({
+      data: z12.string(),
+      format: z12.string(),
+      size: z12.number()
     }),
-    z9.object({
-      output: z9.string(),
-      format: z9.string(),
-      size: z9.number()
+    z12.object({
+      output: z12.string(),
+      format: z12.string(),
+      size: z12.number()
     })
   ]),
   handler: async (p, ctx) => {
@@ -1219,21 +1660,21 @@ var screenshotCommand = registerCommand({
     if (p.output) {
       const dirErr = ensureParentDir(p.output);
       if (dirErr) {
-        return fail3(`Cannot create directory for --output "${p.output}": ${dirErr}`);
+        return fail5(`Cannot create directory for --output "${p.output}": ${dirErr}`);
       }
       try {
         writeFileSync(p.output, buffer, "binary");
       } catch (err) {
-        return fail3(`Failed to write screenshot to "${p.output}": ${err instanceof Error ? err.message : String(err)}`);
+        return fail5(`Failed to write screenshot to "${p.output}": ${err instanceof Error ? err.message : String(err)}`);
       }
-      return ok9({
+      return ok12({
         output: p.output,
         format,
         size: buffer.length
       });
     }
     if (p.base64) {
-      return ok9({
+      return ok12({
         data: buffer.toString("base64"),
         format,
         size: buffer.length
@@ -1242,7 +1683,7 @@ var screenshotCommand = registerCommand({
     ensureScreenshotsDir();
     const screenshotPath = generateScreenshotPath(format);
     writeFileSync(screenshotPath, buffer, "binary");
-    return ok9({
+    return ok12({
       output: screenshotPath,
       format,
       size: buffer.length
@@ -1251,19 +1692,19 @@ var screenshotCommand = registerCommand({
 });
 
 // src/commands/structure.ts
-import { z as z10 } from "zod";
-import { ok as ok10 } from "@dyyz1993/xcli-core";
+import { z as z13 } from "zod";
+import { ok as ok13 } from "@dyyz1993/xcli-core";
 var structureCommand = registerCommand({
   name: "structure",
   description: "Get the DOM structure of the page or an element",
   scope: "page",
   selectorParams: ["selector"],
-  parameters: z10.object({
-    selector: z10.string().optional(),
-    depth: z10.number().optional()
+  parameters: z13.object({
+    selector: z13.string().optional(),
+    depth: z13.number().optional()
   }),
-  result: z10.object({
-    structure: z10.record(z10.unknown())
+  result: z13.object({
+    structure: z13.record(z13.unknown())
   }),
   handler: async (p, ctx) => {
     const structure = await ctx.page.evaluate(
@@ -1295,30 +1736,30 @@ var structureCommand = registerCommand({
       },
       { sel: p.selector || "body", maxDepth: p.depth || 5 }
     );
-    return ok10({ structure });
+    return ok13({ structure });
   }
 });
 
 // src/commands/viewport.ts
-import { z as z11 } from "zod";
-import { ok as ok11 } from "@dyyz1993/xcli-core";
+import { z as z14 } from "zod";
+import { ok as ok14 } from "@dyyz1993/xcli-core";
 var setViewportCommand = registerCommand({
   name: "set-viewport",
   description: "Set the viewport size and properties",
   scope: "browser",
-  parameters: z11.object({
-    width: z11.coerce.number(),
-    height: z11.coerce.number(),
-    deviceScaleFactor: z11.coerce.number().optional(),
-    isMobile: z11.boolean().optional(),
-    hasTouch: z11.boolean().optional()
+  parameters: z14.object({
+    width: z14.coerce.number(),
+    height: z14.coerce.number(),
+    deviceScaleFactor: z14.coerce.number().optional(),
+    isMobile: z14.boolean().optional(),
+    hasTouch: z14.boolean().optional()
   }),
-  result: z11.object({
-    width: z11.number(),
-    height: z11.number(),
-    deviceScaleFactor: z11.number().optional(),
-    isMobile: z11.boolean().optional(),
-    hasTouch: z11.boolean().optional()
+  result: z14.object({
+    width: z14.number(),
+    height: z14.number(),
+    deviceScaleFactor: z14.number().optional(),
+    isMobile: z14.boolean().optional(),
+    hasTouch: z14.boolean().optional()
   }),
   handler: async (p, ctx) => {
     const viewport = ctx.page.viewportSize();
@@ -1331,7 +1772,7 @@ var setViewportCommand = registerCommand({
       ...p.isMobile !== void 0 && { isMobile: p.isMobile },
       ...p.hasTouch !== void 0 && { hasTouch: p.hasTouch }
     });
-    return ok11({
+    return ok14({
       width,
       height,
       ...p.deviceScaleFactor !== void 0 && { deviceScaleFactor: p.deviceScaleFactor },
@@ -1342,17 +1783,17 @@ var setViewportCommand = registerCommand({
 });
 
 // src/commands/frame.ts
-import { z as z12 } from "zod";
-import { ok as ok12, fail as fail4 } from "@dyyz1993/xcli-core";
+import { z as z15 } from "zod";
+import { ok as ok15, fail as fail6 } from "@dyyz1993/xcli-core";
 var framesCommand = registerCommand({
   name: "frames",
   description: "List all frames in the current page",
   scope: "page",
-  result: z12.object({
-    frames: z12.array(z12.object({
-      index: z12.number(),
-      name: z12.string().nullable(),
-      url: z12.string()
+  result: z15.object({
+    frames: z15.array(z15.object({
+      index: z15.number(),
+      name: z15.string().nullable(),
+      url: z15.string()
     }))
   }),
   handler: async (_p, ctx) => {
@@ -1363,21 +1804,21 @@ var framesCommand = registerCommand({
       name: frame.name(),
       url: frame.url()
     }));
-    return ok12({ frames: frameList });
+    return ok15({ frames: frameList });
   }
 });
 var frameCommand = registerCommand({
   name: "frame",
   description: "Get frame info by index or name",
   scope: "page",
-  parameters: z12.object({
-    index: z12.number().int().min(0).optional(),
-    name: z12.string().optional()
+  parameters: z15.object({
+    index: z15.number().int().min(0).optional(),
+    name: z15.string().optional()
   }),
-  result: z12.object({
-    name: z12.string().nullable(),
-    url: z12.string(),
-    error: z12.string().optional()
+  result: z15.object({
+    name: z15.string().nullable(),
+    url: z15.string(),
+    error: z15.string().optional()
   }),
   handler: async (p, ctx) => {
     const discover = ctx.page.discoverFrames;
@@ -1388,12 +1829,12 @@ var frameCommand = registerCommand({
     } else if (p.name !== void 0) {
       targetFrame = rawFrames.find((f) => f.name() === p.name);
     } else {
-      return fail4("Must provide index or name");
+      return fail6("Must provide index or name");
     }
     if (!targetFrame) {
-      return fail4("Frame not found");
+      return fail6("Frame not found");
     }
-    return ok12({
+    return ok15({
       name: targetFrame.name(),
       url: targetFrame.url()
     });
@@ -1401,27 +1842,27 @@ var frameCommand = registerCommand({
 });
 
 // src/commands/ui-debug.ts
-import { z as z13 } from "zod";
-import { ok as ok13 } from "@dyyz1993/xcli-core";
+import { z as z16 } from "zod";
+import { ok as ok16 } from "@dyyz1993/xcli-core";
 var consoleCheckCommand = registerCommand({
   name: "console",
   description: "Collect and analyze browser console messages (errors, warnings, logs)",
   scope: "page",
-  parameters: z13.object({
-    url: z13.string().optional().describe("URL to navigate first (optional, uses current page if omitted)"),
-    duration: z13.number().optional().default(5e3).describe("How long to collect messages (ms)"),
-    filter: z13.enum(["all", "error", "warning", "info", "log"]).optional().default("all"),
-    includeStackTraces: z13.boolean().optional().default(true)
+  parameters: z16.object({
+    url: z16.string().optional().describe("URL to navigate first (optional, uses current page if omitted)"),
+    duration: z16.number().optional().default(5e3).describe("How long to collect messages (ms)"),
+    filter: z16.enum(["all", "error", "warning", "info", "log"]).optional().default("all"),
+    includeStackTraces: z16.boolean().optional().default(true)
   }),
-  result: z13.object({
-    url: z13.string(),
-    duration: z13.number(),
-    total: z13.number(),
-    errors: z13.number(),
-    warnings: z13.number(),
-    messages: z13.array(z13.record(z13.unknown())),
-    summary: z13.string(),
-    passed: z13.boolean()
+  result: z16.object({
+    url: z16.string(),
+    duration: z16.number(),
+    total: z16.number(),
+    errors: z16.number(),
+    warnings: z16.number(),
+    messages: z16.array(z16.record(z16.unknown())),
+    summary: z16.string(),
+    passed: z16.boolean()
   }),
   handler: async (p, ctx) => {
     const { page } = ctx;
@@ -1503,7 +1944,7 @@ ${a.stack || ""}`;
     const filtered = p.filter === "all" ? messages : messages.filter((m) => m.type === p.filter);
     const errorCount = messages.filter((m) => m.type === "error").length;
     const warnCount = messages.filter((m) => m.type === "warning").length;
-    return ok13({
+    return ok16({
       url: page.url(),
       duration: p.duration,
       total: messages.length,
@@ -1519,23 +1960,23 @@ var networkCheckCommand = registerCommand({
   name: "net-debug",
   description: "Monitor and analyze network requests \u2014 capture failed requests, slow responses, status codes",
   scope: "page",
-  parameters: z13.object({
-    url: z13.string().optional().describe("URL to navigate first"),
-    duration: z13.number().optional().default(5e3).describe("How long to monitor (ms)"),
-    filter: z13.enum(["all", "failed", "slow", "error", "xhr", "fetch", "document", "stylesheet", "script", "image"]).optional().default("all"),
-    slowThreshold: z13.number().optional().default(3e3).describe('Threshold for "slow" requests (ms)')
+  parameters: z16.object({
+    url: z16.string().optional().describe("URL to navigate first"),
+    duration: z16.number().optional().default(5e3).describe("How long to monitor (ms)"),
+    filter: z16.enum(["all", "failed", "slow", "error", "xhr", "fetch", "document", "stylesheet", "script", "image"]).optional().default("all"),
+    slowThreshold: z16.number().optional().default(3e3).describe('Threshold for "slow" requests (ms)')
   }),
-  result: z13.object({
-    url: z13.string(),
-    duration: z13.number(),
-    totalRequests: z13.number(),
-    failedRequests: z13.number(),
-    slowRequests: z13.number(),
-    errorRequests: z13.number(),
-    totalSizeKB: z13.number(),
-    requests: z13.array(z13.record(z13.unknown())),
-    summary: z13.string(),
-    passed: z13.boolean()
+  result: z16.object({
+    url: z16.string(),
+    duration: z16.number(),
+    totalRequests: z16.number(),
+    failedRequests: z16.number(),
+    slowRequests: z16.number(),
+    errorRequests: z16.number(),
+    totalSizeKB: z16.number(),
+    requests: z16.array(z16.record(z16.unknown())),
+    summary: z16.string(),
+    passed: z16.boolean()
   }),
   handler: async (p, ctx) => {
     const { page } = ctx;
@@ -1617,7 +2058,7 @@ var networkCheckCommand = registerCommand({
       const slowCount = requests.filter((r) => r.duration >= p.slowThreshold).length;
       const errorCount = requests.filter((r) => r.error).length;
       const totalSize = requests.reduce((sum, r) => sum + r.size, 0);
-      return ok13({
+      return ok16({
         url: page.url(),
         duration: p.duration,
         totalRequests: requests.length,
@@ -1639,17 +2080,17 @@ var perfCheckCommand = registerCommand({
   name: "perf",
   description: "Audit page performance metrics \u2014 load time, FCP, LCP, CLS, TTFB, resource sizes",
   scope: "page",
-  parameters: z13.object({
-    url: z13.string().optional().describe("URL to navigate (uses current page if omitted)"),
-    iterations: z13.number().optional().default(1).describe("Number of iterations to average")
+  parameters: z16.object({
+    url: z16.string().optional().describe("URL to navigate (uses current page if omitted)"),
+    iterations: z16.number().optional().default(1).describe("Number of iterations to average")
   }),
-  result: z13.object({
-    url: z13.string(),
-    iterations: z13.number(),
-    metrics: z13.record(z13.unknown()),
-    allIterations: z13.array(z13.record(z13.unknown())).optional(),
-    passed: z13.boolean(),
-    summary: z13.string()
+  result: z16.object({
+    url: z16.string(),
+    iterations: z16.number(),
+    metrics: z16.record(z16.unknown()),
+    allIterations: z16.array(z16.record(z16.unknown())).optional(),
+    passed: z16.boolean(),
+    summary: z16.string()
   }),
   handler: async (p, ctx) => {
     const { page } = ctx;
@@ -1711,7 +2152,7 @@ var perfCheckCommand = registerCommand({
       if (resourceStats) avg.resourceStats = resourceStats;
       return avg;
     })();
-    return ok13({
+    return ok16({
       url: page.url(),
       iterations: p.iterations,
       metrics: avgMetrics,
@@ -1725,23 +2166,23 @@ var healthCheckCommand = registerCommand({
   name: "health",
   description: "Comprehensive page health check \u2014 broken links, missing images, console errors, SEO issues",
   scope: "page",
-  parameters: z13.object({
-    url: z13.string().optional().describe("URL to check"),
-    checkLinks: z13.boolean().optional().default(true).describe("Check for broken links"),
-    checkImages: z13.boolean().optional().default(true).describe("Check for missing/broken images"),
-    checkMeta: z13.boolean().optional().default(true).describe("Check SEO meta tags"),
-    maxLinks: z13.number().optional().default(50).describe("Max links to check")
+  parameters: z16.object({
+    url: z16.string().optional().describe("URL to check"),
+    checkLinks: z16.boolean().optional().default(true).describe("Check for broken links"),
+    checkImages: z16.boolean().optional().default(true).describe("Check for missing/broken images"),
+    checkMeta: z16.boolean().optional().default(true).describe("Check SEO meta tags"),
+    maxLinks: z16.number().optional().default(50).describe("Max links to check")
   }),
-  result: z13.object({
-    url: z13.string(),
-    title: z13.string(),
-    passed: z13.boolean(),
-    totalIssues: z13.number(),
-    errors: z13.number(),
-    warnings: z13.number(),
-    info: z13.number(),
-    issues: z13.array(z13.record(z13.unknown())),
-    summary: z13.string()
+  result: z16.object({
+    url: z16.string(),
+    title: z16.string(),
+    passed: z16.boolean(),
+    totalIssues: z16.number(),
+    errors: z16.number(),
+    warnings: z16.number(),
+    info: z16.number(),
+    issues: z16.array(z16.record(z16.unknown())),
+    summary: z16.string()
   }),
   handler: async (p, ctx) => {
     const { page } = ctx;
@@ -1828,7 +2269,7 @@ var healthCheckCommand = registerCommand({
     }, { checkLinks: p.checkLinks, checkImages: p.checkImages, checkMeta: p.checkMeta, maxLinks: p.maxLinks });
     const errors = result.issues.filter((i) => i.severity === "error").length;
     const warnings = result.issues.filter((i) => i.severity === "warning").length;
-    return ok13({
+    return ok16({
       url: result.url,
       title: result.title,
       passed: errors === 0,
@@ -1843,68 +2284,66 @@ var healthCheckCommand = registerCommand({
 });
 
 // src/commands/actions.ts
-import { z as z14 } from "zod";
-import { ok as ok14 } from "@dyyz1993/xcli-core";
+import { z as z17 } from "zod";
+import { ok as ok17 } from "@dyyz1993/xcli-core";
 import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
-import { join as join3 } from "path";
-import { homedir as homedir3 } from "os";
-var SCREENSHOTS_DIR2 = join3(homedir3(), ".xbrowser", "screenshots");
+import { join as join5 } from "path";
 function ensureScreenshotsDir2() {
-  mkdirSync2(SCREENSHOTS_DIR2, { recursive: true });
+  mkdirSync2(resolveScreenshotsDir(), { recursive: true });
 }
 function generateScreenshotPath2(format) {
   const timestamp = Date.now();
   const random = Math.random().toString(36).slice(2, 8);
   const ext = format === "jpeg" ? "jpg" : "png";
-  return join3(SCREENSHOTS_DIR2, `screenshot-${timestamp}-${random}.${ext}`);
+  return join5(resolveScreenshotsDir(), `screenshot-${timestamp}-${random}.${ext}`);
 }
-var waitActionSchema = z14.object({
-  type: z14.literal("wait"),
-  milliseconds: z14.number().positive().optional(),
-  selector: z14.string().optional()
+var waitActionSchema = z17.object({
+  type: z17.literal("wait"),
+  milliseconds: z17.number().positive().optional(),
+  selector: z17.string().optional()
 }).refine(
   (d) => (d.milliseconds !== void 0 || d.selector !== void 0) && !(d.milliseconds !== void 0 && d.selector !== void 0),
   { message: "Either 'milliseconds' or 'selector' must be provided, but not both." }
 );
-var clickActionSchema = z14.object({
-  type: z14.literal("click"),
-  selector: z14.string(),
-  all: z14.boolean().optional()
+var clickActionSchema = z17.object({
+  type: z17.literal("click"),
+  selector: z17.string(),
+  all: z17.boolean().optional()
 });
-var screenshotActionSchema = z14.object({
-  type: z14.literal("screenshot"),
-  fullPage: z14.boolean().optional(),
-  quality: z14.number().min(1).max(100).optional(),
-  viewport: z14.object({ width: z14.number().int().positive(), height: z14.number().int().positive() }).optional(),
-  base64: z14.boolean().optional().describe("Return base64 data instead of file path")
+var screenshotActionSchema = z17.object({
+  type: z17.literal("screenshot"),
+  fullPage: z17.boolean().optional(),
+  quality: z17.number().min(1).max(100).optional(),
+  viewport: z17.object({ width: z17.number().int().positive(), height: z17.number().int().positive() }).optional(),
+  base64: z17.boolean().optional().describe("Return base64 data instead of file path")
 });
-var writeActionSchema = z14.object({
-  type: z14.literal("write"),
-  text: z14.string()
+var writeActionSchema = z17.object({
+  type: z17.literal("write"),
+  text: z17.string()
 });
-var pressActionSchema = z14.object({
-  type: z14.literal("press"),
-  key: z14.string()
+var pressActionSchema = z17.object({
+  type: z17.literal("press"),
+  key: z17.string()
 });
-var scrollActionSchema = z14.object({
-  type: z14.literal("scroll"),
-  direction: z14.enum(["up", "down"]).optional(),
-  selector: z14.string().optional()
+var scrollActionSchema = z17.object({
+  type: z17.literal("scroll"),
+  direction: z17.enum(["up", "down"]).optional(),
+  selector: z17.string().optional()
 });
-var scrapeActionSchema = z14.object({
-  type: z14.literal("scrape")
+var scrapeActionSchema = z17.object({
+  type: z17.literal("scrape")
 });
-var executeJavascriptActionSchema = z14.object({
-  type: z14.literal("executeJavascript"),
-  script: z14.string()
+var executeJavascriptActionSchema = z17.object({
+  type: z17.literal("executeJavascript"),
+  script: z17.string()
 });
-var pdfActionSchema = z14.object({
-  type: z14.literal("pdf"),
-  landscape: z14.boolean().optional(),
-  scale: z14.number().optional(),
-  format: z14.enum(["A0", "A1", "A2", "A3", "A4", "A5", "A6", "Letter", "Legal", "Tabloid", "Ledger"]).optional()
+var pdfActionSchema = z17.object({
+  type: z17.literal("pdf"),
+  landscape: z17.boolean().optional(),
+  scale: z17.number().optional(),
+  format: z17.enum(["A0", "A1", "A2", "A3", "A4", "A5", "A6", "Letter", "Legal", "Tabloid", "Ledger"]).optional()
 });
-var actionSchema = z14.union([
+var actionSchema = z17.union([
   waitActionSchema,
   clickActionSchema,
   screenshotActionSchema,
@@ -1995,11 +2434,11 @@ var actionsCommand = registerCommand({
   name: "actions",
   description: "Execute a sequence of actions (wait, click, scroll, screenshot, fill, etc.)",
   scope: "page",
-  parameters: z14.object({
-    url: z14.string().describe("Starting URL"),
-    actions: z14.array(actionSchema).max(MAX_ACTIONS).describe("Array of actions (max 50)"),
-    output: z14.enum(["text", "json"]).default("json").describe("Output format: text or json"),
-    timeout: z14.number().default(60).describe("Overall timeout in seconds (default: 60)")
+  parameters: z17.object({
+    url: z17.string().describe("Starting URL"),
+    actions: z17.array(actionSchema).max(MAX_ACTIONS).describe("Array of actions (max 50)"),
+    output: z17.enum(["text", "json"]).default("json").describe("Output format: text or json"),
+    timeout: z17.number().default(60).describe("Overall timeout in seconds (default: 60)")
   }),
   handler: async (p, ctx) => {
     await ctx.page.goto(p.url, { waitUntil: "domcontentloaded" });
@@ -2019,14 +2458,14 @@ var actionsCommand = registerCommand({
     const finalUrl = ctx.page.url();
     const timedOut = results.length < p.actions.length;
     if (p.output === "text") {
-      return ok14({
+      return ok17({
         title,
         url: finalUrl,
         actions: results.map((r) => JSON.stringify(r)).join("\n"),
         ...timedOut ? { warning: `Timed out after ${p.timeout}s, completed ${results.length}/${p.actions.length} actions` } : {}
       });
     }
-    return ok14({
+    return ok17({
       title,
       url: finalUrl,
       results,
@@ -2036,8 +2475,8 @@ var actionsCommand = registerCommand({
 });
 
 // src/commands/scrape.ts
-import { z as z15 } from "zod";
-import { ok as ok15, fail as fail5 } from "@dyyz1993/xcli-core";
+import { z as z18 } from "zod";
+import { ok as ok18, fail as fail7 } from "@dyyz1993/xcli-core";
 
 // src/lib/html-to-markdown.ts
 import * as cheerio from "cheerio";
@@ -2422,15 +2861,15 @@ var scrapeCommand = registerCommand({
   description: "Scrape a page and convert to Markdown (with JS rendering)",
   scope: "project",
   selectorParams: ["selector"],
-  parameters: z15.object({
-    url: z15.string().optional(),
-    selector: z15.string().optional(),
-    timeout: z15.number().default(3e4),
-    format: z15.enum(["markdown", "html", "text"]).default("markdown"),
-    onlyMainContent: z15.boolean().default(true),
-    retries: z15.number().int().min(0).max(5).optional().default(2).describe("\u91CD\u8BD5\u6B21\u6570\uFF08\u9ED8\u8BA4 2\uFF09"),
-    waitAfterLoad: z15.number().int().optional().default(0).describe("\u9875\u9762\u52A0\u8F7D\u540E\u989D\u5916\u7B49\u5F85\u6BEB\u79D2"),
-    mode: z15.enum(["raw", "clean", "compact", "smart"]).default("raw").describe("\u8F93\u51FA\u6A21\u5F0F\uFF1Araw\uFF08\u9ED8\u8BA4\uFF09/ clean\uFF08\u7ED3\u6784\u5316\uFF09/ compact\uFF08\u7CBE\u7B80\uFF09/ smart\uFF08\u7ED3\u6784\u5316\uFF0C\u7559\u7ED9 agent \u589E\u5F3A\uFF09")
+  parameters: z18.object({
+    url: z18.string().optional(),
+    selector: z18.string().optional(),
+    timeout: z18.number().default(3e4),
+    format: z18.enum(["markdown", "html", "text"]).default("markdown"),
+    onlyMainContent: z18.boolean().default(true),
+    retries: z18.number().int().min(0).max(5).optional().default(2).describe("\u91CD\u8BD5\u6B21\u6570\uFF08\u9ED8\u8BA4 2\uFF09"),
+    waitAfterLoad: z18.number().int().optional().default(0).describe("\u9875\u9762\u52A0\u8F7D\u540E\u989D\u5916\u7B49\u5F85\u6BEB\u79D2"),
+    mode: z18.enum(["raw", "clean", "compact", "smart"]).default("raw").describe("\u8F93\u51FA\u6A21\u5F0F\uFF1Araw\uFF08\u9ED8\u8BA4\uFF09/ clean\uFF08\u7ED3\u6784\u5316\uFF09/ compact\uFF08\u7CBE\u7B80\uFF09/ smart\uFF08\u7ED3\u6784\u5316\uFF0C\u7559\u7ED9 agent \u589E\u5F3A\uFF09")
   }),
   handler: async (p, ctx) => {
     const { context, page } = await createEphemeralContext(resolveLaunchOpts(ctx));
@@ -2438,7 +2877,7 @@ var scrapeCommand = registerCommand({
     try {
       const targetUrl = p.url || page.url();
       if (!targetUrl || targetUrl === "about:blank") {
-        return fail5("URL is required. Provide a URL or connect to a browser (--cdp) with a non-blank page.");
+        return fail7("URL is required. Provide a URL or connect to a browser (--cdp) with a non-blank page.");
       }
       let lastError;
       for (let attempt = 1; attempt <= maxAttempts; attempt++) {
@@ -2508,7 +2947,7 @@ var scrapeCommand = registerCommand({
             } catch {
             }
             if (p.mode === "smart") {
-              return ok15(structured);
+              return ok18(structured);
             }
             if (p.mode === "compact") {
               const compactData = structured.tables.length > 0 ? structured.tables.map((t) => ({
@@ -2521,9 +2960,9 @@ var scrapeCommand = registerCommand({
                   return compact;
                 })
               })) : structured.mainText?.substring(0, 500);
-              return ok15({ url: structured.url, title: structured.title, data: compactData });
+              return ok18({ url: structured.url, title: structured.title, data: compactData });
             }
-            return ok15(structured);
+            return ok18(structured);
           }
           let content;
           switch (p.format) {
@@ -2582,7 +3021,7 @@ var scrapeCommand = registerCommand({
               content = await page.innerText("body");
               break;
           }
-          return ok15({ content, title, url: finalUrl });
+          return ok18({ content, title, url: finalUrl });
         } catch (err) {
           lastError = err instanceof Error ? err : new Error(String(err));
           if (attempt < maxAttempts) {
@@ -2592,20 +3031,20 @@ var scrapeCommand = registerCommand({
           }
         }
       }
-      return fail5(`Scrape failed after ${maxAttempts} attempt(s): ${lastError?.message ?? "unknown error"}`);
+      return fail7(`Scrape failed after ${maxAttempts} attempt(s): ${lastError?.message ?? "unknown error"}`);
     } finally {
       await closeEphemeralContext(context);
     }
   },
-  result: z15.object({
-    url: z15.string(),
-    title: z15.string()
+  result: z18.object({
+    url: z18.string(),
+    title: z18.string()
   }).passthrough()
 });
 
 // src/commands/map.ts
-import { z as z16 } from "zod";
-import { ok as ok16, fail as fail6 } from "@dyyz1993/xcli-core";
+import { z as z19 } from "zod";
+import { ok as ok19, fail as fail8 } from "@dyyz1993/xcli-core";
 
 // src/utils/url.ts
 var SKIP_EXTENSIONS = /* @__PURE__ */ new Set([
@@ -2840,21 +3279,21 @@ var mapCommand = registerCommand({
   name: "map",
   description: "Discover all URLs on a website via sitemap and page link extraction",
   scope: "project",
-  parameters: z16.object({
-    url: z16.string().optional(),
-    search: z16.string().optional(),
-    sitemap: z16.enum(["include", "only"]).optional(),
-    includeSubdomains: z16.boolean().optional(),
-    allowExternalLinks: z16.boolean().optional().describe("Include links to external domains"),
-    limit: z16.number().optional(),
-    verbose: z16.boolean().default(false).describe("Show progress feedback")
+  parameters: z19.object({
+    url: z19.string().optional(),
+    search: z19.string().optional(),
+    sitemap: z19.enum(["include", "only"]).optional(),
+    includeSubdomains: z19.boolean().optional(),
+    allowExternalLinks: z19.boolean().optional().describe("Include links to external domains"),
+    limit: z19.number().optional(),
+    verbose: z19.boolean().default(false).describe("Show progress feedback")
   }),
   handler: async (p, ctx) => {
     const { context, page } = await createEphemeralContext(resolveLaunchOpts(ctx));
     try {
       const targetUrl = p.url || page.url();
       if (!targetUrl || targetUrl === "about:blank") {
-        return fail6("URL is required. Provide a URL or connect to a browser (--cdp) with a non-blank page.");
+        return fail8("URL is required. Provide a URL or connect to a browser (--cdp) with a non-blank page.");
       }
       const links = await discoverUrls(page, targetUrl, {
         sitemap: p.sitemap,
@@ -2865,7 +3304,7 @@ var mapCommand = registerCommand({
         verbose: p.verbose
       });
       const linkObjects = links.map((url) => ({ url }));
-      return ok16({
+      return ok19({
         links: linkObjects,
         success: true
       });
@@ -2873,15 +3312,15 @@ var mapCommand = registerCommand({
       await closeEphemeralContext(context);
     }
   },
-  result: z16.object({
-    links: z16.array(z16.object({ url: z16.string() })),
-    success: z16.boolean()
+  result: z19.object({
+    links: z19.array(z19.object({ url: z19.string() })),
+    success: z19.boolean()
   })
 });
 
 // src/commands/crawl.ts
-import { z as z17 } from "zod";
-import { ok as ok17 } from "@dyyz1993/xcli-core";
+import { z as z20 } from "zod";
+import { ok as ok20 } from "@dyyz1993/xcli-core";
 function stripHashAnchorQuery(url) {
   try {
     const parsed = new URL(url);
@@ -3058,21 +3497,21 @@ var crawlCommand = registerCommand({
   name: "crawl",
   description: "Crawl a website and extract content from all pages",
   scope: "project",
-  parameters: z17.object({
-    url: z17.string(),
-    limit: z17.number().default(10),
-    maxDepth: z17.number().default(3),
-    includePaths: z17.array(z17.string()).optional(),
-    excludePaths: z17.array(z17.string()).optional(),
-    allowSubdomains: z17.boolean().default(false),
-    allowExternalLinks: z17.boolean().default(false),
-    allowBackwardCrawling: z17.boolean().default(false),
-    enableSpa: z17.boolean().default(true).describe("Disable to skip SPA route detection"),
-    format: z17.enum(["markdown", "html"]).default("markdown"),
-    onlyMainContent: z17.boolean().default(true),
-    concurrency: z17.number().default(3),
-    retries: z17.number().default(2),
-    verbose: z17.boolean().default(false)
+  parameters: z20.object({
+    url: z20.string(),
+    limit: z20.number().default(10),
+    maxDepth: z20.number().default(3),
+    includePaths: z20.array(z20.string()).optional(),
+    excludePaths: z20.array(z20.string()).optional(),
+    allowSubdomains: z20.boolean().default(false),
+    allowExternalLinks: z20.boolean().default(false),
+    allowBackwardCrawling: z20.boolean().default(false),
+    enableSpa: z20.boolean().default(true).describe("Disable to skip SPA route detection"),
+    format: z20.enum(["markdown", "html"]).default("markdown"),
+    onlyMainContent: z20.boolean().default(true),
+    concurrency: z20.number().default(3),
+    retries: z20.number().default(2),
+    verbose: z20.boolean().default(false)
   }),
   handler: async (p, ctx) => {
     const startUrl = new URL(p.url);
@@ -3211,7 +3650,7 @@ var crawlCommand = registerCommand({
         if (errorPages.length > 0) {
           response.errors = errorPages;
         }
-        return ok17(response);
+        return ok20(response);
       } finally {
         for (const ctx2 of contexts) {
           await ctx2.close().catch(() => {
@@ -3221,15 +3660,15 @@ var crawlCommand = registerCommand({
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       const successPages = results.filter((r) => !isPageError(r));
-      return ok17({ pages: successPages, total: successPages.length, success: false, error: message });
+      return ok20({ pages: successPages, total: successPages.length, success: false, error: message });
     }
   }
 });
 
 // src/commands/search.ts
-import { z as z18 } from "zod";
+import { z as z21 } from "zod";
 import * as cheerio2 from "cheerio";
-import { ok as ok18 } from "@dyyz1993/xcli-core";
+import { ok as ok21 } from "@dyyz1993/xcli-core";
 function getRecencyParams(recency) {
   const now = Math.floor(Date.now() / 1e3);
   switch (recency) {
@@ -3563,16 +4002,16 @@ var searchCommand = registerCommand({
   name: "search",
   description: "Search the web and extract results with engine fallback",
   scope: "project",
-  parameters: z18.object({
-    query: z18.string(),
-    engine: z18.string().optional(),
-    limit: z18.number().default(10),
-    full: z18.boolean().default(false),
-    format: z18.enum(["markdown", "json", "text"]).default("markdown"),
-    timeout: z18.number().default(15e3),
-    recency: z18.enum(["hour", "day", "week", "month", "year"]).optional().describe("Filter by time: hour/day/week/month/year"),
-    fallback: z18.boolean().default(false).describe("Sequential engine fallback instead of parallel"),
-    site: z18.string().optional().describe("Limit results to a specific site (e.g. github.com, v2ex.com)")
+  parameters: z21.object({
+    query: z21.string(),
+    engine: z21.string().optional(),
+    limit: z21.number().default(10),
+    full: z21.boolean().default(false),
+    format: z21.enum(["markdown", "json", "text"]).default("markdown"),
+    timeout: z21.number().default(15e3),
+    recency: z21.enum(["hour", "day", "week", "month", "year"]).optional().describe("Filter by time: hour/day/week/month/year"),
+    fallback: z21.boolean().default(false).describe("Sequential engine fallback instead of parallel"),
+    site: z21.string().optional().describe("Limit results to a specific site (e.g. github.com, v2ex.com)")
   }),
   handler: async (p, ctx) => {
     const { context } = await createEphemeralContext(resolveLaunchOpts(ctx));
@@ -3678,7 +4117,7 @@ ${errors.map((e) => `  - ${e.engine}: ${e.error}`).join("\n")}`
           lines.push(`> ${r.snippet}`);
           lines.push("");
         }
-        return ok18({ ...searchResult, content: lines.join("\n") });
+        return ok21({ ...searchResult, content: lines.join("\n") });
       }
       if (p.format === "text") {
         const lines = [`Search: ${searchResult.query} (Engine: ${searchResult.engine}, Total: ${searchResult.total})`, ""];
@@ -3688,9 +4127,9 @@ ${errors.map((e) => `  - ${e.engine}: ${e.error}`).join("\n")}`
           lines.push(`   ${r.snippet}`);
           lines.push("");
         }
-        return ok18({ ...searchResult, content: lines.join("\n") });
+        return ok21({ ...searchResult, content: lines.join("\n") });
       }
-      return ok18(searchResult);
+      return ok21(searchResult);
     } finally {
       await closeEphemeralContext(context);
     }
@@ -3698,8 +4137,8 @@ ${errors.map((e) => `  - ${e.engine}: ${e.error}`).join("\n")}`
 });
 
 // src/commands/network.ts
-import { z as z19 } from "zod";
-import { ok as ok19, fail as fail7 } from "@dyyz1993/xcli-core";
+import { z as z22 } from "zod";
+import { ok as ok22, fail as fail9 } from "@dyyz1993/xcli-core";
 function extractPath2(url) {
   try {
     const u = new URL(url);
@@ -3797,19 +4236,19 @@ var networkCommand = registerCommand({
   name: "network",
   description: "Capture and filter network responses from a URL",
   scope: "project",
-  parameters: z19.object({
-    url: z19.string(),
-    filter: z19.string().optional(),
-    match: z19.string().optional(),
-    search: z19.string().optional().describe("Search within all captured response bodies"),
-    console: z19.boolean().default(false),
-    timeout: z19.number().default(3e4),
-    wait: z19.number().default(3e3),
-    limit: z19.number().default(50),
-    format: z19.enum(["summary", "json"]).default("summary"),
-    ws: z19.boolean().optional().default(false).describe("Only show WebSocket messages"),
-    listen: z19.boolean().optional().default(false).describe("\u76D1\u542C\u6A21\u5F0F\uFF1A\u4F7F\u7528\u73B0\u6709 session \u7684 page\uFF0C\u7B49\u5F85\u6307\u5B9A\u65F6\u95F4\u6355\u83B7\u8BF7\u6C42"),
-    duration: z19.number().int().optional().default(15e3).describe("\u76D1\u542C\u6A21\u5F0F\u7B49\u5F85\u65F6\u957F\uFF08\u6BEB\u79D2\uFF0C\u9ED8\u8BA4 15000\uFF09")
+  parameters: z22.object({
+    url: z22.string(),
+    filter: z22.string().optional(),
+    match: z22.string().optional(),
+    search: z22.string().optional().describe("Search within all captured response bodies"),
+    console: z22.boolean().default(false),
+    timeout: z22.number().default(3e4),
+    wait: z22.number().default(3e3),
+    limit: z22.number().default(50),
+    format: z22.enum(["summary", "json"]).default("summary"),
+    ws: z22.boolean().optional().default(false).describe("Only show WebSocket messages"),
+    listen: z22.boolean().optional().default(false).describe("\u76D1\u542C\u6A21\u5F0F\uFF1A\u4F7F\u7528\u73B0\u6709 session \u7684 page\uFF0C\u7B49\u5F85\u6307\u5B9A\u65F6\u95F4\u6355\u83B7\u8BF7\u6C42"),
+    duration: z22.number().int().optional().default(15e3).describe("\u76D1\u542C\u6A21\u5F0F\u7B49\u5F85\u65F6\u957F\uFF08\u6BEB\u79D2\uFF0C\u9ED8\u8BA4 15000\uFF09")
   }),
   handler: async (p, ctx) => {
     const startTime = Date.now();
@@ -3864,7 +4303,7 @@ var networkCommand = registerCommand({
     };
     if (p.listen) {
       const page2 = ctx.page;
-      if (!page2) return fail7("No active page. Use --cdp to connect first.");
+      if (!page2) return fail9("No active page. Use --cdp to connect first.");
       const captures = [];
       const consoleMessages = [];
       const wsCaptures = [];
@@ -3891,7 +4330,7 @@ var networkCommand = registerCommand({
       page2.off("response", handler);
       const duration = Date.now() - startTime;
       if (p.ws && wsCaptures.length > 0) {
-        return ok19({
+        return ok22({
           url: "[listen mode]",
           duration,
           total: captures.length,
@@ -3905,9 +4344,9 @@ var networkCommand = registerCommand({
         });
       }
       if (p.format === "json") {
-        return ok19(buildJsonOutput("[listen mode]", captures, consoleMessages, captures.length, wsCaptures));
+        return ok22(buildJsonOutput("[listen mode]", captures, consoleMessages, captures.length, wsCaptures));
       }
-      return ok19(buildSummaryOutput("[listen mode]", duration, captures, consoleMessages, captures.length, wsCaptures));
+      return ok22(buildSummaryOutput("[listen mode]", duration, captures, consoleMessages, captures.length, wsCaptures));
     }
     const { context, page } = await createEphemeralContext(resolveLaunchOpts(ctx));
     try {
@@ -3962,7 +4401,7 @@ var networkCommand = registerCommand({
       }
       const duration = Date.now() - startTime;
       if (p.ws && wsCaptures.length > 0) {
-        return ok19({
+        return ok22({
           url: p.url,
           duration,
           total: captures.length,
@@ -3976,9 +4415,9 @@ var networkCommand = registerCommand({
         });
       }
       if (p.format === "json") {
-        return ok19(buildJsonOutput(p.url, results, consoleMessages, totalCount, wsCaptures, searchResults));
+        return ok22(buildJsonOutput(p.url, results, consoleMessages, totalCount, wsCaptures, searchResults));
       }
-      return ok19(buildSummaryOutput(p.url, duration, results, consoleMessages, totalCount, wsCaptures));
+      return ok22(buildSummaryOutput(p.url, duration, results, consoleMessages, totalCount, wsCaptures));
     } finally {
       await closeEphemeralContext(context);
     }
@@ -3986,7 +4425,7 @@ var networkCommand = registerCommand({
 });
 
 // src/commands/ai-search-engines.ts
-import { z as z20 } from "zod";
+import { z as z23 } from "zod";
 var ENGINE_CONFIGS = {
   deepseek: {
     key: "deepseek",
@@ -4240,7 +4679,7 @@ var ENGINE_CONFIGS = {
   }
 };
 var ALL_ENGINE_KEYS = Object.keys(ENGINE_CONFIGS);
-var ENGINE_KEY_ENUM = z20.enum(ALL_ENGINE_KEYS);
+var ENGINE_KEY_ENUM = z23.enum(ALL_ENGINE_KEYS);
 function getEngineConfig(key) {
   return ENGINE_CONFIGS[key];
 }
@@ -4520,8 +4959,8 @@ function parseMarkdownResults(rawText) {
 }
 
 // src/commands/snapshot.ts
-import { z as z21 } from "zod";
-import { ok as ok20, fail as fail8, normalizeTips as normalizeTips3 } from "@dyyz1993/xcli-core";
+import { z as z24 } from "zod";
+import { ok as ok23, fail as fail10, normalizeTips as normalizeTips3 } from "@dyyz1993/xcli-core";
 
 // src/runtime/ref-store.ts
 var sessions = /* @__PURE__ */ new Map();
@@ -4762,8 +5201,8 @@ async function resolveRefParams(page, params, selectorKeys, cache, sessionId) {
 }
 
 // src/utils/site-semantics.ts
-import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, existsSync, readFileSync } from "fs";
-import { join as join4, dirname as dirname2 } from "path";
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join6, dirname as dirname2 } from "path";
 import { homedir as homedir4 } from "os";
 import { stringify, parse } from "yaml";
 import { execFile } from "child_process";
@@ -4841,10 +5280,10 @@ function inferAction(role, label) {
   return {};
 }
 function getSemanticsDir() {
-  return join4(homedir4(), ".xbrowser", "site-semantics");
+  return join6(homedir4(), ".xbrowser", "site-semantics");
 }
 function getSemanticsPath(domain) {
-  return join4(getSemanticsDir(), `${domain}.yaml`);
+  return join6(getSemanticsDir(), `${domain}.yaml`);
 }
 function extractDomain2(url) {
   try {
@@ -4858,9 +5297,9 @@ function saveSemantics(domain, pagePath, url, elements) {
   const filePath = getSemanticsPath(domain);
   const dir = dirname2(filePath);
   let site;
-  if (existsSync(filePath)) {
+  if (existsSync3(filePath)) {
     try {
-      site = parse(readFileSync(filePath, "utf-8"));
+      site = parse(readFileSync3(filePath, "utf-8"));
     } catch {
       site = { site: domain, pages: {} };
     }
@@ -4880,16 +5319,16 @@ function saveSemantics(domain, pagePath, url, elements) {
     }
   }
   site.updated_at = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  if (!existsSync(dir)) {
+  if (!existsSync3(dir)) {
     mkdirSync3(dir, { recursive: true });
   }
   writeFileSync3(filePath, stringify(site, { lineWidth: 0 }));
 }
 function loadSemantics(domain) {
   const filePath = getSemanticsPath(domain);
-  if (!existsSync(filePath)) return null;
+  if (!existsSync3(filePath)) return null;
   try {
-    return parse(readFileSync(filePath, "utf-8"));
+    return parse(readFileSync3(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -5433,24 +5872,24 @@ var snapshotCommand = registerCommand({
   description: "Capture a quick page state snapshot \u2014 aria tree, visible text, or DOM summary",
   scope: "page",
   selectorParams: ["selector"],
-  parameters: z21.object({
-    type: z21.enum(["aria", "text", "dom", "all"]).default("aria").describe("Snapshot type: aria (accessibility tree), text (visible text), dom (element summary), all (combined)"),
-    selector: z21.string().optional().describe("Scope to a specific element"),
-    depth: z21.number().optional().default(6).describe("Max depth for DOM/aria tree"),
-    interactive: z21.boolean().optional().default(false).describe("Return interactive agent refs only"),
-    interactiveOnly: z21.boolean().optional().default(false).describe("Alias for interactive"),
-    i: z21.boolean().optional().default(false).describe("Short alias for interactive"),
-    compact: z21.boolean().optional().default(false).describe("Include compact xbrowser style snapshot text"),
-    c: z21.boolean().optional().default(false).describe("Short alias for compact"),
-    selectors: z21.boolean().optional().default(false).describe("Include ref to CSS selector map"),
-    all: z21.boolean().optional().default(false).describe("Include hidden interactive targets when using interactive snapshot")
+  parameters: z24.object({
+    type: z24.enum(["aria", "text", "dom", "all"]).default("aria").describe("Snapshot type: aria (accessibility tree), text (visible text), dom (element summary), all (combined)"),
+    selector: z24.string().optional().describe("Scope to a specific element"),
+    depth: z24.number().optional().default(6).describe("Max depth for DOM/aria tree"),
+    interactive: z24.boolean().optional().default(false).describe("Return interactive agent refs only"),
+    interactiveOnly: z24.boolean().optional().default(false).describe("Alias for interactive"),
+    i: z24.boolean().optional().default(false).describe("Short alias for interactive"),
+    compact: z24.boolean().optional().default(false).describe("Include compact xbrowser style snapshot text"),
+    c: z24.boolean().optional().default(false).describe("Short alias for compact"),
+    selectors: z24.boolean().optional().default(false).describe("Include ref to CSS selector map"),
+    all: z24.boolean().optional().default(false).describe("Include hidden interactive targets when using interactive snapshot")
   }),
-  result: z21.object({
-    url: z21.string(),
-    title: z21.string(),
-    aria: z21.string().optional(),
-    text: z21.string().optional(),
-    dom: z21.record(z21.unknown()).optional()
+  result: z24.object({
+    url: z24.string(),
+    title: z24.string(),
+    aria: z24.string().optional(),
+    text: z24.string().optional(),
+    dom: z24.record(z24.unknown()).optional()
   }),
   handler: async (p, ctx) => {
     const page = ctx.page;
@@ -5464,7 +5903,7 @@ var snapshotCommand = registerCommand({
       if (p.compact || p.c || p.interactive || p.interactiveOnly || p.i) {
         observation.compact = formatObservationCompact(observation, { selectors: p.selectors });
       }
-      return ok20(observation, normalizeTips3([
+      return ok23(observation, normalizeTips3([
         `refs refreshed for ${observation.targets.length} targets; use click @e1 or fill @e2 "text"`
       ]));
     }
@@ -5472,15 +5911,15 @@ var snapshotCommand = registerCommand({
       const aria = await captureAriaSnapshot(page, p.selector, p.depth);
       const tips = await buildRefTips(page, aria);
       persistSemantics(url, aria);
-      return ok20({ url, title, aria }, normalizeTips3(tips));
+      return ok23({ url, title, aria }, normalizeTips3(tips));
     }
     if (p.type === "text") {
       const text = await captureTextSnapshot(page, p.selector);
-      return ok20({ url, title, text });
+      return ok23({ url, title, text });
     }
     if (p.type === "dom") {
       const dom = await captureDomSnapshot(page, p.selector, p.depth ?? 6);
-      return ok20({ url, title, dom });
+      return ok23({ url, title, dom });
     }
     if (p.type === "all") {
       const [aria, text, dom] = await Promise.all([
@@ -5490,9 +5929,9 @@ var snapshotCommand = registerCommand({
       ]);
       const tips = await buildRefTips(page, aria);
       persistSemantics(url, aria);
-      return ok20({ url, title, aria, text, dom }, normalizeTips3(tips));
+      return ok23({ url, title, aria, text, dom }, normalizeTips3(tips));
     }
-    return fail8(`Unknown snapshot type: ${p.type}`);
+    return fail10(`Unknown snapshot type: ${p.type}`);
   }
 });
 function persistSemantics(url, aria) {
@@ -5569,22 +6008,22 @@ async function captureDomSnapshot(page, selector, maxDepth) {
 }
 
 // src/commands/agent.ts
-import { z as z22 } from "zod";
-import { ok as ok21, normalizeTips as normalizeTips4 } from "@dyyz1993/xcli-core";
+import { z as z25 } from "zod";
+import { ok as ok24, normalizeTips as normalizeTips4 } from "@dyyz1993/xcli-core";
 var observeCommand = registerCommand({
   name: "observe",
   description: "Observe the current page as structured agent targets with session refs",
   scope: "page",
-  parameters: z22.object({
-    includeHidden: z22.boolean().optional().default(false).describe("Include hidden elements in the target list"),
-    limit: z22.number().int().positive().max(300).optional().default(80).describe("Maximum number of targets to return"),
-    compact: z22.boolean().optional().default(false).describe("Include compact xbrowser style snapshot text"),
-    selectors: z22.boolean().optional().default(false).describe("Include ref to stable CSS selector map")
+  parameters: z25.object({
+    includeHidden: z25.boolean().optional().default(false).describe("Include hidden elements in the target list"),
+    limit: z25.number().int().positive().max(300).optional().default(80).describe("Maximum number of targets to return"),
+    compact: z25.boolean().optional().default(false).describe("Include compact xbrowser style snapshot text"),
+    selectors: z25.boolean().optional().default(false).describe("Include ref to stable CSS selector map")
   }),
-  result: z22.object({
-    targets: z22.array(z22.record(z22.unknown())),
-    selectors: z22.record(z22.unknown()).optional(),
-    compact: z22.string().optional()
+  result: z25.object({
+    targets: z25.array(z25.record(z25.unknown())),
+    selectors: z25.record(z25.unknown()).optional(),
+    compact: z25.string().optional()
   }).passthrough(),
   handler: async (p, ctx) => {
     const observation = await observePage(ctx.page, ctx.sessionId, {
@@ -5593,7 +6032,7 @@ var observeCommand = registerCommand({
     });
     if (p.selectors) observation.selectors = buildSelectorMap(observation);
     if (p.compact) observation.compact = formatObservationCompact(observation, { selectors: p.selectors });
-    return ok21(observation, normalizeTips4([
+    return ok24(observation, normalizeTips4([
       `refs refreshed for ${observation.targets.length} targets; use act --ref @e1 --action click or click @e1`
     ]));
   }
@@ -5603,14 +6042,14 @@ var actCommand = registerCommand({
   description: "Perform an agent action using an observe ref or explicit selector",
   scope: "element",
   selectorParams: ["selector"],
-  parameters: z22.object({
-    action: z22.enum(["click", "fill", "type", "press", "select", "check", "hover"]).default("click"),
-    ref: z22.string().optional().describe("Session-scoped ref returned by observe, such as e1"),
-    selector: z22.string().optional().describe("CSS selector fallback when no ref is available"),
-    value: z22.string().optional().describe("Value for fill/type/select"),
-    key: z22.string().optional().describe("Key for press"),
-    force: z22.boolean().optional().default(false).describe("Bypass actionability checks"),
-    timeout: z22.number().optional().default(1e4).describe("Playwright action timeout in milliseconds")
+  parameters: z25.object({
+    action: z25.enum(["click", "fill", "type", "press", "select", "check", "hover"]).default("click"),
+    ref: z25.string().optional().describe("Session-scoped ref returned by observe, such as e1"),
+    selector: z25.string().optional().describe("CSS selector fallback when no ref is available"),
+    value: z25.string().optional().describe("Value for fill/type/select"),
+    key: z25.string().optional().describe("Key for press"),
+    force: z25.boolean().optional().default(false).describe("Bypass actionability checks"),
+    timeout: z25.number().optional().default(1e4).describe("Playwright action timeout in milliseconds")
   }).refine((p) => !!p.ref || !!p.selector, {
     message: "Either ref or selector is required"
   }),
@@ -5624,7 +6063,7 @@ var actCommand = registerCommand({
         tips: normalizeTips4(result.stale ? ["run observe again to refresh refs"] : [])
       };
     }
-    return ok21(result, normalizeTips4(result.stale ? ["ref screen hash changed; run observe if the next action is uncertain"] : []));
+    return ok24(result, normalizeTips4(result.stale ? ["ref screen hash changed; run observe if the next action is uncertain"] : []));
   }
 });
 var waitForCommand = registerCommand({
@@ -5632,16 +6071,16 @@ var waitForCommand = registerCommand({
   description: "Wait for agent predicates such as text, URL, load state, selector state, or screen hash changes",
   scope: "page",
   selectorParams: ["selector"],
-  parameters: z22.object({
-    selector: z22.string().optional().describe("CSS selector or observe ref to wait for"),
-    state: z22.enum(["attached", "detached", "visible", "hidden"]).optional().default("visible"),
-    text: z22.string().optional().describe("Visible text to wait for"),
-    url: z22.string().optional().describe("URL substring or glob pattern to wait for"),
-    load: z22.enum(["load", "domcontentloaded", "networkidle"]).optional().describe("Load state to wait for"),
-    fn: z22.string().optional().describe("JavaScript predicate to wait for"),
-    screenHashChanged: z22.string().optional().describe("Previous screenHash from observe"),
-    timeout: z22.number().optional().default(3e4),
-    pollInterval: z22.number().optional().default(200)
+  parameters: z25.object({
+    selector: z25.string().optional().describe("CSS selector or observe ref to wait for"),
+    state: z25.enum(["attached", "detached", "visible", "hidden"]).optional().default("visible"),
+    text: z25.string().optional().describe("Visible text to wait for"),
+    url: z25.string().optional().describe("URL substring or glob pattern to wait for"),
+    load: z25.enum(["load", "domcontentloaded", "networkidle"]).optional().describe("Load state to wait for"),
+    fn: z25.string().optional().describe("JavaScript predicate to wait for"),
+    screenHashChanged: z25.string().optional().describe("Previous screenHash from observe"),
+    timeout: z25.number().optional().default(3e4),
+    pollInterval: z25.number().optional().default(200)
   }).refine((p) => [p.selector, p.text, p.url, p.load, p.fn, p.screenHashChanged].filter(Boolean).length === 1, {
     message: "Provide exactly one wait predicate: selector, text, url, load, fn, or screenHashChanged"
   }),
@@ -5655,30 +6094,30 @@ var waitForCommand = registerCommand({
         tips: []
       };
     }
-    return ok21(result);
+    return ok24(result);
   }
 });
 
 // src/commands/tab.ts
-import { z as z23 } from "zod";
-import { ok as ok22, fail as fail9 } from "@dyyz1993/xcli-core";
-var TabParams = z23.object({
-  subcommand: z23.enum(["list", "new", "close", "switch"]),
-  url: z23.string().optional(),
-  index: z23.number().int().min(0).optional()
+import { z as z26 } from "zod";
+import { ok as ok25, fail as fail11 } from "@dyyz1993/xcli-core";
+var TabParams = z26.object({
+  subcommand: z26.enum(["list", "new", "close", "switch"]),
+  url: z26.string().optional(),
+  index: z26.number().int().min(0).optional()
 });
 var tabCommand = registerCommand({
   name: "tab",
   description: "Manage browser tabs: list, new, close, switch",
   scope: "page",
   parameters: TabParams,
-  result: z23.object({
-    success: z23.boolean(),
-    data: z23.unknown()
+  result: z26.object({
+    success: z26.boolean(),
+    data: z26.unknown()
   }),
   handler: async (p, ctx) => {
     if (!ctx.browserContext) {
-      return fail9("No browser context available. Use --cdp to connect to a browser first.");
+      return fail11("No browser context available. Use --cdp to connect to a browser first.");
     }
     const pages = ctx.browserContext.pages();
     switch (p.subcommand) {
@@ -5691,7 +6130,7 @@ var tabCommand = registerCommand({
       case "switch":
         return handleSwitch(p, pages, ctx);
       default:
-        return fail9(`Unknown subcommand: ${p.subcommand}`);
+        return fail11(`Unknown subcommand: ${p.subcommand}`);
     }
   }
 });
@@ -5706,7 +6145,7 @@ async function handleList(pages, ctx) {
     if (isActive) activeIndex = i;
     tabs.push({ index: i, url, title, active: isActive });
   }
-  return ok22({ tabs, total: tabs.length, activeIndex });
+  return ok25({ tabs, total: tabs.length, activeIndex });
 }
 async function handleNew(p, _pages, ctx) {
   const newPage = await ctx.browserContext.newPage();
@@ -5734,7 +6173,7 @@ async function handleNew(p, _pages, ctx) {
   const title = await newPage.title().catch(() => "");
   const allPages = ctx.browserContext.pages();
   const newIndex = allPages.indexOf(newPage);
-  return ok22({
+  return ok25({
     index: newIndex >= 0 ? newIndex : allPages.length - 1,
     url: newPage.url(),
     title,
@@ -5745,11 +6184,11 @@ async function handleNew(p, _pages, ctx) {
 async function handleClose(p, ctx) {
   const currentPages = ctx.browserContext.pages();
   if (currentPages.length <= 1) {
-    return fail9("Cannot close the last remaining tab");
+    return fail11("Cannot close the last remaining tab");
   }
   const closeIndex = p.index ?? currentPages.findIndex((pg) => pg === ctx.page);
   if (closeIndex < 0 || closeIndex >= currentPages.length) {
-    return fail9(`Invalid tab index: ${closeIndex}. Valid range: 0-${currentPages.length - 1}`);
+    return fail11(`Invalid tab index: ${closeIndex}. Valid range: 0-${currentPages.length - 1}`);
   }
   const pageToClose = currentPages[closeIndex];
   const isActivePage = pageToClose === ctx.page;
@@ -5764,7 +6203,7 @@ async function handleClose(p, ctx) {
     }
     ctx.page = newActivePage;
   }
-  return ok22({
+  return ok25({
     closedIndex: closeIndex,
     total: remainingPages.length,
     activeIndex: isActivePage ? closeIndex < remainingPages.length ? closeIndex : remainingPages.length - 1 : remainingPages.findIndex((pg) => pg === ctx.page)
@@ -5772,10 +6211,10 @@ async function handleClose(p, ctx) {
 }
 async function handleSwitch(p, pages, ctx) {
   if (p.index === void 0) {
-    return fail9("Parameter --index is required for switch subcommand");
+    return fail11("Parameter --index is required for switch subcommand");
   }
   if (p.index < 0 || p.index >= pages.length) {
-    return fail9(`Invalid tab index: ${p.index}. Valid range: 0-${pages.length - 1}`);
+    return fail11(`Invalid tab index: ${p.index}. Valid range: 0-${pages.length - 1}`);
   }
   const targetPage = pages[p.index];
   await targetPage.bringToFront().catch(() => {
@@ -5785,13 +6224,19 @@ async function handleSwitch(p, pages, ctx) {
     if (okProbe) break;
     await new Promise((r) => setTimeout(r, 300));
   }
+  try {
+    const mouse = targetPage.mouse;
+    if (mouse) await mouse.move(1, 1).catch(() => {
+    });
+  } catch {
+  }
   const session = ctx.sessionId ? getSessionById(ctx.sessionId) : void 0;
   if (session) {
     setActivePage(session, targetPage);
   }
   ctx.page = targetPage;
   const title = await targetPage.title().catch(() => "");
-  return ok22({
+  return ok25({
     index: p.index,
     url: targetPage.url(),
     title,
@@ -5800,9 +6245,9 @@ async function handleSwitch(p, pages, ctx) {
 }
 
 // src/commands/addinitscript.ts
-import { z as z24 } from "zod";
-import { ok as ok23 } from "@dyyz1993/xcli-core";
-import { readFileSync as readFileSync2 } from "fs";
+import { z as z27 } from "zod";
+import { ok as ok26 } from "@dyyz1993/xcli-core";
+import { readFileSync as readFileSync4 } from "fs";
 
 // src/chain-parser.ts
 import { splitCommand, parseCommandArgs } from "@dyyz1993/xcli-core";
@@ -5942,14 +6387,14 @@ registerCommandDefinition("tab", ["subcommand"]);
 registerCommandDefinition("mouse", ["action", "x", "y"]);
 
 // src/commands/addinitscript.ts
-var InitScriptParams = z24.object({
-  script: z24.string().optional(),
-  file: z24.string().optional(),
-  stdin: z24.boolean().optional(),
-  name: z24.string().optional(),
-  list: z24.boolean().optional(),
-  remove: z24.union([z24.string(), z24.boolean()]).optional(),
-  base64: z24.string().optional()
+var InitScriptParams = z27.object({
+  script: z27.string().optional(),
+  file: z27.string().optional(),
+  stdin: z27.boolean().optional(),
+  name: z27.string().optional(),
+  list: z27.boolean().optional(),
+  remove: z27.union([z27.string(), z27.boolean()]).optional(),
+  base64: z27.string().optional()
 });
 var registeredScripts = /* @__PURE__ */ new Map();
 function resolveScriptContent(params) {
@@ -5957,7 +6402,7 @@ function resolveScriptContent(params) {
     return Buffer.from(params.base64, "base64").toString("utf-8");
   }
   if (params.file) {
-    return readFileSync2(params.file, "utf-8");
+    return readFileSync4(params.file, "utf-8");
   }
   if (params.stdin) {
     return null;
@@ -5983,14 +6428,14 @@ var addInitScriptCommand = registerCommand({
   description: "Add an initialization script that runs on every page load",
   scope: "page",
   parameters: InitScriptParams,
-  result: z24.object({
-    scripts: z24.array(z24.object({ name: z24.string(), size: z24.number(), preview: z24.string() })).optional(),
-    removed: z24.string().optional(),
-    existed: z24.boolean().optional(),
-    error: z24.string().optional(),
-    registered: z24.string().optional(),
-    hint: z24.string().optional(),
-    executedImmediately: z24.boolean().optional()
+  result: z27.object({
+    scripts: z27.array(z27.object({ name: z27.string(), size: z27.number(), preview: z27.string() })).optional(),
+    removed: z27.string().optional(),
+    existed: z27.boolean().optional(),
+    error: z27.string().optional(),
+    registered: z27.string().optional(),
+    hint: z27.string().optional(),
+    executedImmediately: z27.boolean().optional()
   }).passthrough(),
   handler: async (params, ctx) => {
     if (params.list) {
@@ -5999,20 +6444,20 @@ var addInitScriptCommand = registerCommand({
         size: content2.length,
         preview: content2.slice(0, 80)
       }));
-      return ok23({ scripts });
+      return ok26({ scripts });
     }
     if (params.remove && typeof params.remove === "string") {
       const existed = registeredScripts.delete(params.remove);
-      return ok23({ removed: params.remove, existed });
+      return ok26({ removed: params.remove, existed });
     }
     const removeTarget = (typeof params.remove === "string" ? params.remove : null) || (params.name && !resolveScriptContent(params) ? params.name : null);
     if (removeTarget && !resolveScriptContent(params)) {
       const existed = registeredScripts.delete(removeTarget);
-      return ok23({ removed: removeTarget, existed });
+      return ok26({ removed: removeTarget, existed });
     }
     let content = params.stdin ? await readStdin() : resolveScriptContent(params);
     if (!content) {
-      return ok23({ error: "No script content provided. Use --script, --file, --stdin, or --base64" });
+      return ok26({ error: "No script content provided. Use --script, --file, --stdin, or --base64" });
     }
     const scriptName = params.name ?? `script-${Date.now()}`;
     registeredScripts.set(scriptName, content);
@@ -6020,45 +6465,45 @@ var addInitScriptCommand = registerCommand({
     try {
       await ctx.page.evaluate(content);
     } catch {
-      return ok23({
+      return ok26({
         registered: scriptName,
         hint: "Script registered for future page loads; immediate execution skipped (page may not be ready)"
       });
     }
-    return ok23({ registered: scriptName, executedImmediately: true });
+    return ok26({ registered: scriptName, executedImmediately: true });
   }
 });
 registerCommandDefinition("addinitscript", ["script"]);
 
 // src/commands/find.ts
-import { z as z25 } from "zod";
-import { ok as ok24, fail as fail10, normalizeTips as normalizeTips5 } from "@dyyz1993/xcli-core";
-var actionSchema2 = z25.enum(["click", "fill", "type", "select", "hover", "check"]);
+import { z as z28 } from "zod";
+import { ok as ok27, fail as fail12, normalizeTips as normalizeTips5 } from "@dyyz1993/xcli-core";
+var actionSchema2 = z28.enum(["click", "fill", "type", "select", "hover", "check"]);
 var findCommand = registerCommand({
   name: "find",
   description: "Find elements by semantic strategy (text/role/label/placeholder/testid) and optionally perform an action",
   scope: "page",
-  parameters: z25.object({
-    strategy: z25.enum(["text", "role", "label", "placeholder", "testid", "alt", "title", "first", "last", "nth"]),
-    value: z25.string(),
-    name: z25.string().optional(),
-    exact: z25.boolean().optional().default(false),
-    operation: z25.string().optional().describe('Trailing operation syntax, e.g. click, fill "text", type "text"'),
+  parameters: z28.object({
+    strategy: z28.enum(["text", "role", "label", "placeholder", "testid", "alt", "title", "first", "last", "nth"]),
+    value: z28.string(),
+    name: z28.string().optional(),
+    exact: z28.boolean().optional().default(false),
+    operation: z28.string().optional().describe('Trailing operation syntax, e.g. click, fill "text", type "text"'),
     action: actionSchema2.optional().describe("Action to perform when not using trailing operation syntax"),
-    actionValue: z25.string().optional().describe("Value for fill/type/select when using action"),
-    index: z25.number().int().optional().describe("Index for nth strategy"),
-    click: z25.boolean().optional().default(false),
-    fill: z25.string().optional(),
-    type: z25.string().optional(),
-    select: z25.string().optional(),
-    hover: z25.boolean().optional().default(false),
-    check: z25.boolean().optional().default(false),
-    timeout: z25.number().optional().default(1e4)
+    actionValue: z28.string().optional().describe("Value for fill/type/select when using action"),
+    index: z28.number().int().optional().describe("Index for nth strategy"),
+    click: z28.boolean().optional().default(false),
+    fill: z28.string().optional(),
+    type: z28.string().optional(),
+    select: z28.string().optional(),
+    hover: z28.boolean().optional().default(false),
+    check: z28.boolean().optional().default(false),
+    timeout: z28.number().optional().default(1e4)
   }),
-  result: z25.object({
-    matched: z25.number(),
-    selector: z25.string(),
-    action: z25.string().optional()
+  result: z28.object({
+    matched: z28.number(),
+    selector: z28.string(),
+    action: z28.string().optional()
   }),
   handler: async (p, ctx) => {
     const page = ctx.page;
@@ -6073,7 +6518,7 @@ var findCommand = registerCommand({
     });
     const count = await locator.count();
     if (count === 0) {
-      return fail10(`No element found with ${p.strategy}="${p.value}"`);
+      return fail12(`No element found with ${p.strategy}="${p.value}"`);
     }
     const tips = [];
     const target = selectTarget(locator, p.strategy);
@@ -6085,15 +6530,15 @@ var findCommand = registerCommand({
       await target.click({ timeout: p.timeout, force: true });
       return okWithTips({ matched: count, selector, action: "click" }, tips);
     } else if (actionName === "fill") {
-      if (actionValue === void 0) return fail10("find fill requires a value");
+      if (actionValue === void 0) return fail12("find fill requires a value");
       await target.fill(actionValue, { timeout: p.timeout, force: true });
       return okWithTips({ matched: count, selector, action: `fill("${actionValue}")` }, tips);
     } else if (actionName === "type") {
-      if (actionValue === void 0) return fail10("find type requires a value");
+      if (actionValue === void 0) return fail12("find type requires a value");
       await target.type(actionValue, { delay: 10, timeout: p.timeout });
       return okWithTips({ matched: count, selector, action: `type("${actionValue}")` }, tips);
     } else if (actionName === "select") {
-      if (actionValue === void 0) return fail10("find select requires a value");
+      if (actionValue === void 0) return fail12("find select requires a value");
       await target.selectOption(actionValue);
       return okWithTips({ matched: count, selector, action: `select("${actionValue}")` }, tips);
     } else if (actionName === "hover") {
@@ -6107,7 +6552,7 @@ var findCommand = registerCommand({
   }
 });
 function okWithTips(data, tips) {
-  const result = ok24(data);
+  const result = ok27(data);
   if (tips.length > 0) result.tips = normalizeTips5(tips);
   return result;
 }
@@ -6231,7 +6676,7 @@ function attachWaitForHuman(ctx, getOrCreateWSServer) {
     if (!ctx.page) {
       throw new Error("waitForHuman requires an active page");
     }
-    const { HumanInteractionManager: HumanInteractionManager2 } = await import("./human-interaction-C5OEGXGO.js");
+    const { HumanInteractionManager: HumanInteractionManager2 } = await import("./human-interaction-Y5IDH6LD.js");
     const wsServer2 = await getOrCreateWSServer(ctx.browserContext);
     const manager = new HumanInteractionManager2(wsServer2, ctx.page);
     return manager.waitForHuman(options);
@@ -6255,18 +6700,18 @@ import {
   Core
 } from "@dyyz1993/xcli-core";
 import { resolve as resolve2 } from "path";
-import { existsSync as existsSync4, readdirSync } from "fs";
+import { existsSync as existsSync6, readdirSync } from "fs";
 import { homedir as homedir5 } from "os";
 
 // src/plugin/metadata-parser.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { resolve } from "path";
 
 // src/utils/json-file.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "fs";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
 function readJsonFile(filePath, defaultValue) {
   try {
-    const content = readFileSync3(filePath, "utf-8");
+    const content = readFileSync5(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return defaultValue;
@@ -6278,7 +6723,7 @@ var PluginMetadataParser = class {
   static XBROWSER_KEYWORDS = ["xbrowser", "xbrowser-plugin"];
   static parseFromPackageJson(pluginPath) {
     const packageJsonPath = resolve(pluginPath, "package.json");
-    if (!existsSync2(packageJsonPath)) {
+    if (!existsSync4(packageJsonPath)) {
       return null;
     }
     const packageJson = readJsonFile(packageJsonPath, null);
@@ -6342,20 +6787,20 @@ var PluginMetadataParser = class {
 };
 
 // src/plugin/ensure-deps.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "fs";
+import { join as join7 } from "path";
 import { execSync } from "child_process";
 var SHARED_PLUGIN_DEPENDENCIES = {
   "zod": "^3.24.0",
   "@dyyz1993/xcli-core": "^0.12.1"
 };
 function ensurePluginDependencies(pluginsDir) {
-  const zodPath = join5(pluginsDir, "node_modules", "zod");
-  if (existsSync3(zodPath)) return;
+  const zodPath = join7(pluginsDir, "node_modules", "zod");
+  if (existsSync5(zodPath)) return;
   mkdirSync4(pluginsDir, { recursive: true });
-  const pkgPath = join5(pluginsDir, "package.json");
+  const pkgPath = join7(pluginsDir, "package.json");
   let pkg = {};
-  if (existsSync3(pkgPath)) {
+  if (existsSync5(pkgPath)) {
     try {
       pkg = readJsonFile(pkgPath, {});
     } catch {
@@ -6369,7 +6814,7 @@ function ensurePluginDependencies(pluginsDir) {
       needsInstall = true;
     }
   }
-  if (!needsInstall && existsSync3(join5(pluginsDir, "node_modules"))) return;
+  if (!needsInstall && existsSync5(join7(pluginsDir, "node_modules"))) return;
   pkg.dependencies = existingDeps;
   pkg.private = true;
   pkg.description = pkg.description || "xbrowser plugins \u2014 shared dependencies";
@@ -6627,7 +7072,7 @@ var XBrowserPluginLoader = class {
     const loaded = [];
     const seen = /* @__PURE__ */ new Set();
     for (const dir of dirs) {
-      if (!existsSync4(dir)) continue;
+      if (!existsSync6(dir)) continue;
       const entries = readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
@@ -6635,12 +7080,12 @@ var XBrowserPluginLoader = class {
         seen.add(entry.name);
         const pluginDir = resolve2(dir, entry.name);
         let indexPath = resolve2(pluginDir, "index.js");
-        if (!existsSync4(indexPath)) {
+        if (!existsSync6(indexPath)) {
           indexPath = resolve2(pluginDir, "index.ts");
         }
-        if (!existsSync4(indexPath)) continue;
+        if (!existsSync6(indexPath)) continue;
         try {
-          if (!existsSync4(resolve2(pluginDir, "package.json"))) {
+          if (!existsSync6(resolve2(pluginDir, "package.json"))) {
             console.warn(`\u26A0\uFE0F  Plugin "${entry.name}" has no package.json. Use "xbrowser create ${entry.name} --template static" for proper structure.`);
           } else {
             const metadata = PluginMetadataParser.parseFromPackageJson(pluginDir);
@@ -7297,7 +7742,7 @@ async function loadHooks() {
 
 // src/executor.ts
 import { homedir as homedir6 } from "os";
-import { join as join6 } from "path";
+import { join as join8 } from "path";
 function levenshtein(a, b) {
   const m = a.length, n = b.length;
   const dp = Array(m + 1).fill(null).map(() => Array(n + 1).fill(0));
@@ -7312,7 +7757,7 @@ function levenshtein(a, b) {
 }
 var NAVIGATION_COMMANDS = /* @__PURE__ */ new Set(["goto", "back", "forward", "refresh"]);
 var snapshotHintShown = /* @__PURE__ */ new WeakSet();
-var CONFIG_DIR2 = join6(homedir6(), ".xbrowser");
+var CONFIG_DIR2 = join8(homedir6(), ".xbrowser");
 var storageCache = /* @__PURE__ */ new Map();
 function getPluginStorage(pluginName) {
   if (!storageCache.has(pluginName)) {
@@ -7324,7 +7769,7 @@ var archiveInitialized = false;
 function ensureArchiveInit() {
   if (!archiveInitialized) {
     try {
-      configureArchiveStore({ archiveDir: join6(homedir6(), ".xbrowser", "archives") });
+      configureArchiveStore({ archiveDir: join8(homedir6(), ".xbrowser", "archives") });
     } catch {
     }
     archiveInitialized = true;
@@ -7348,7 +7793,7 @@ async function guardCheck(commandName) {
   }
 }
 function errorResult(message) {
-  return { ...fail11(message), duration: 0 };
+  return { ...fail13(message), duration: 0 };
 }
 function tipsToMessages(tips) {
   if (!tips || tips.length === 0) return [];
@@ -7428,7 +7873,7 @@ async function executeCommand(commandName, params, sessionName = "default", extr
   }
   let targetPageOverride = null;
   if (_target && extraOpts?.cdpEndpoint) {
-    const { findTargetPage } = await import("./browser-V3JIWSTR.js");
+    const { findTargetPage } = await import("./browser-T7OVLAEC.js");
     targetPageOverride = await findTargetPage(extraOpts.cdpEndpoint, _target);
     if (!targetPageOverride) {
       return errorResult(`Target "${_target}" not found. Use 'xbrowser targets --cdp ${extraOpts.cdpEndpoint}' to list available pages.`);
@@ -7445,8 +7890,15 @@ async function executeCommand(commandName, params, sessionName = "default", extr
     params = result.data;
   }
   if (command.scope !== "cli" && !process.env.XBROWSER_DAEMON_WORKER) {
-    const { forwardExec } = await import("./daemon-client-Y2YSZCGK.js");
-    const result = await forwardExec(commandName, params, sessionName, extraOpts?.cdpEndpoint);
+    const { forwardExec } = await import("./daemon-client-HEGAXWGK.js");
+    const longRunning = /^(vision-task|crawl|scrape|record|replay)$/.test(commandName);
+    const result = await forwardExec(
+      commandName,
+      params,
+      sessionName,
+      extraOpts?.cdpEndpoint,
+      longRunning ? 20 * 6e4 : void 0
+    );
     if (result) return result;
   }
   let session;
@@ -7614,7 +8066,7 @@ async function executeCommand(commandName, params, sessionName = "default", extr
         timestamp: start
       });
       if (isSuccess) {
-        return { ...ok25(raw.data, merged.length > 0 ? merged : raw.tips), duration, ...hookOutputs ? { hookOutputs } : {} };
+        return { ...ok28(raw.data, merged.length > 0 ? merged : raw.tips), duration, ...hookOutputs ? { hookOutputs } : {} };
       }
       return { success: false, data: raw.data, message: raw.message, tips: mergedOrRaw, duration, ...hookOutputs ? { hookOutputs } : {} };
     }
@@ -7628,14 +8080,14 @@ async function executeCommand(commandName, params, sessionName = "default", extr
       duration,
       timestamp: start
     });
-    return { ...ok25(raw, smartTipNormalized), duration, ...hookOutputs ? { hookOutputs } : {} };
+    return { ...ok28(raw, smartTipNormalized), duration, ...hookOutputs ? { hookOutputs } : {} };
   } catch (err) {
     const end = Date.now();
     const duration = end - start;
     const errorMessage = errMsg(err);
     if (session?.page && process.env.XBROWSER_RECOVERY && !extraOpts?._recoveryAttempted) {
       try {
-        const { attemptRecovery } = await import("./recovery-ZJVVHP7N.js");
+        const { attemptRecovery } = await import("./recovery-L5GLDX4O.js");
         const recovery = await attemptRecovery(
           session.page,
           sessionName,
@@ -7673,7 +8125,7 @@ async function executeCommand(commandName, params, sessionName = "default", extr
       duration,
       timestamp: start
     });
-    return { ...fail11(errorMessage), duration };
+    return { ...fail13(errorMessage), duration };
   } finally {
   }
 }
@@ -7714,7 +8166,7 @@ async function executeChain(input, options) {
             results.push({
               command: cmdName,
               raw: cmdStr,
-              ...fail11(`Plugin "${cmdName}" requires a sub-command`),
+              ...fail13(`Plugin "${cmdName}" requires a sub-command`),
               duration: 0
             });
             if (type === "and") {
@@ -7733,7 +8185,7 @@ async function executeChain(input, options) {
             results.push({
               command: cmdName,
               raw: cmdStr,
-              ...fail11(`Unknown command "${subCommand}" for plugin "${cmdName}"`),
+              ...fail13(`Unknown command "${subCommand}" for plugin "${cmdName}"`),
               duration: 0
             });
             if (type === "and") {
@@ -7837,7 +8289,7 @@ async function executeChain(input, options) {
             results.push({
               command: `${cmdName} ${subCommand}`,
               raw: cmdStr,
-              ...ok25(data),
+              ...ok28(data),
               duration: duration2,
               ...hookOutputs ? { hookOutputs } : {}
             });
@@ -7865,7 +8317,7 @@ async function executeChain(input, options) {
             results.push({
               command: `${cmdName} ${subCommand}`,
               raw: cmdStr,
-              ...fail11(errorMessage),
+              ...fail13(errorMessage),
               duration: duration2
             });
             if (type === "and") {
@@ -8179,25 +8631,25 @@ Run "xbrowser config list" to see current keys.`
 
 // src/plugin/installer.ts
 import {
-  existsSync as existsSync10,
+  existsSync as existsSync12,
   readdirSync as readdirSync2,
   mkdirSync as mkdirSync8,
   rmSync as rmSync6,
   copyFileSync,
   cpSync as cpSync6,
-  readFileSync as readFileSync8,
+  readFileSync as readFileSync10,
   writeFileSync as writeFileSync10
 } from "fs";
 import { resolve as resolve8, basename as basename2, dirname as dirname4 } from "path";
 import { homedir as homedir7 } from "os";
 
 // src/plugin/install-sources/local.ts
-import { existsSync as existsSync5, cpSync, rmSync } from "fs";
+import { existsSync as existsSync7, cpSync, rmSync } from "fs";
 import { resolve as resolve3 } from "path";
 import { verifyPlugin, safeCleanup } from "@dyyz1993/xcli-core";
 async function installFromLocal(source, name, targetDir) {
   const srcPath = resolve3(source);
-  if (!existsSync5(srcPath)) {
+  if (!existsSync7(srcPath)) {
     throw new Error(`Local path does not exist: ${srcPath}`);
   }
   const tmpTarget = `${targetDir}-tmp-${Date.now()}`;
@@ -8210,7 +8662,7 @@ async function installFromLocal(source, name, targetDir) {
       safeCleanup(tmpTarget);
       throw new Error(`Invalid plugin: ${verify.error}`);
     }
-    if (existsSync5(targetDir)) {
+    if (existsSync7(targetDir)) {
       rmSync(targetDir, { recursive: true, force: true });
     }
     cpSync(tmpTarget, targetDir, { recursive: true, force: true });
@@ -8230,8 +8682,8 @@ async function installFromLocal(source, name, targetDir) {
 }
 
 // src/plugin/install-sources/npm.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync6, rmSync as rmSync2, cpSync as cpSync2 } from "fs";
-import { resolve as resolve4, join as join7 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync6, rmSync as rmSync2, cpSync as cpSync2 } from "fs";
+import { resolve as resolve4, join as join9 } from "path";
 import { tmpdir } from "os";
 import {
   downloadToFile,
@@ -8304,13 +8756,13 @@ async function installFromNpm(packageName, name, targetDir) {
     throw new Error(`No tarball URL for ${packageName}@${latestVersion}`);
   }
   const tarballUrl = versionMeta.dist.tarball;
-  const tmpDir = join7(tmpdir(), `xbrowser-npm-${Date.now()}`);
+  const tmpDir = join9(tmpdir(), `xbrowser-npm-${Date.now()}`);
   mkdirSync5(tmpDir, { recursive: true });
   let warnings = [];
   try {
-    const tarballPath = join7(tmpDir, `${name}.tgz`);
+    const tarballPath = join9(tmpDir, `${name}.tgz`);
     await downloadToFile(tarballUrl, tarballPath);
-    const extractDir = join7(tmpDir, "extracted");
+    const extractDir = join9(tmpDir, "extracted");
     extractTarGz(tarballPath, extractDir);
     flattenPackageRoot(extractDir);
     const verify = verifyPlugin2(extractDir, { metadataField: "xbrowser" });
@@ -8318,13 +8770,13 @@ async function installFromNpm(packageName, name, targetDir) {
     if (!verify.valid) {
       throw new Error(`Invalid npm plugin: ${verify.error}`);
     }
-    if (existsSync6(targetDir)) {
+    if (existsSync8(targetDir)) {
       rmSync2(targetDir, { recursive: true, force: true });
     }
     cpSync2(extractDir, targetDir, { recursive: true, force: true });
     const pkgPath = resolve4(targetDir, "package.json");
-    if (existsSync6(pkgPath)) {
-      const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+    if (existsSync8(pkgPath)) {
+      const pkg = JSON.parse(readFileSync6(pkgPath, "utf-8"));
       if (!pkg._npmSource) {
         pkg._npmSource = { name: packageName, version: latestVersion };
         writeFileSync6(pkgPath, JSON.stringify(pkg, null, 2));
@@ -8344,13 +8796,13 @@ async function installFromNpm(packageName, name, targetDir) {
 }
 
 // src/plugin/install-sources/git.ts
-import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync7, rmSync as rmSync3, cpSync as cpSync3 } from "fs";
-import { resolve as resolve5, join as join8 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync7, rmSync as rmSync3, cpSync as cpSync3 } from "fs";
+import { resolve as resolve5, join as join10 } from "path";
 import { tmpdir as tmpdir2 } from "os";
 import { execSync as execSync2 } from "child_process";
 import { verifyPlugin as verifyPlugin3, safeCleanup as safeCleanup3 } from "@dyyz1993/xcli-core";
 async function installFromGit(gitUrl, name, targetDir) {
-  const tmpDir = join8(tmpdir2(), `xbrowser-git-${Date.now()}`);
+  const tmpDir = join10(tmpdir2(), `xbrowser-git-${Date.now()}`);
   let warnings = [];
   try {
     execSync2(`git clone --depth 1 "${gitUrl}" "${tmpDir}"`, { stdio: "pipe" });
@@ -8359,14 +8811,14 @@ async function installFromGit(gitUrl, name, targetDir) {
     if (!verify.valid) {
       throw new Error(`Invalid git plugin: ${verify.error}`);
     }
-    if (existsSync7(targetDir)) {
+    if (existsSync9(targetDir)) {
       rmSync3(targetDir, { recursive: true, force: true });
     }
     cpSync3(tmpDir, targetDir, { recursive: true, force: true });
     rmSync3(resolve5(targetDir, ".git"), { recursive: true, force: true });
     const pkgPath = resolve5(targetDir, "package.json");
-    if (existsSync7(pkgPath)) {
-      const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+    if (existsSync9(pkgPath)) {
+      const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
       if (!pkg._gitSource) {
         pkg._gitSource = { url: gitUrl };
         writeFileSync7(pkgPath, JSON.stringify(pkg, null, 2));
@@ -8386,8 +8838,8 @@ async function installFromGit(gitUrl, name, targetDir) {
 }
 
 // src/plugin/install-sources/url.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync8, rmSync as rmSync4, cpSync as cpSync4 } from "fs";
-import { resolve as resolve6, join as join9, basename } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync8, rmSync as rmSync4, cpSync as cpSync4 } from "fs";
+import { resolve as resolve6, join as join11, basename } from "path";
 import { tmpdir as tmpdir3 } from "os";
 import {
   downloadToFile as downloadToFile2,
@@ -8397,14 +8849,14 @@ import {
   safeCleanup as safeCleanup4
 } from "@dyyz1993/xcli-core";
 async function installFromUrl(url, name, targetDir) {
-  const tmpDir = join9(tmpdir3(), `xbrowser-url-${Date.now()}`);
+  const tmpDir = join11(tmpdir3(), `xbrowser-url-${Date.now()}`);
   mkdirSync6(tmpDir, { recursive: true });
   let warnings = [];
   try {
     const fileName = basename(new URL(url).pathname) || "plugin.tar.gz";
-    const tarballPath = join9(tmpDir, fileName);
+    const tarballPath = join11(tmpDir, fileName);
     await downloadToFile2(url, tarballPath);
-    const extractDir = join9(tmpDir, "extracted");
+    const extractDir = join11(tmpDir, "extracted");
     extractTarGz2(tarballPath, extractDir);
     flattenPackageRoot2(extractDir);
     const verify = verifyPlugin4(extractDir, { metadataField: "xbrowser" });
@@ -8412,13 +8864,13 @@ async function installFromUrl(url, name, targetDir) {
     if (!verify.valid) {
       throw new Error(`Invalid plugin from URL: ${verify.error}`);
     }
-    if (existsSync8(targetDir)) {
+    if (existsSync10(targetDir)) {
       rmSync4(targetDir, { recursive: true, force: true });
     }
     cpSync4(extractDir, targetDir, { recursive: true, force: true });
     const pkgPath = resolve6(targetDir, "package.json");
-    if (existsSync8(pkgPath)) {
-      const pkg = JSON.parse(readFileSync6(pkgPath, "utf-8"));
+    if (existsSync10(pkgPath)) {
+      const pkg = JSON.parse(readFileSync8(pkgPath, "utf-8"));
       if (!pkg._urlSource) {
         pkg._urlSource = { url };
         writeFileSync8(pkgPath, JSON.stringify(pkg, null, 2));
@@ -8439,14 +8891,14 @@ async function installFromUrl(url, name, targetDir) {
 
 // src/plugin/install-sources/marketplace.ts
 import {
-  existsSync as existsSync9,
+  existsSync as existsSync11,
   mkdirSync as mkdirSync7,
   writeFileSync as writeFileSync9,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync9,
   rmSync as rmSync5,
   cpSync as cpSync5
 } from "fs";
-import { resolve as resolve7, join as join10, dirname as dirname3 } from "path";
+import { resolve as resolve7, join as join12, dirname as dirname3 } from "path";
 import { tmpdir as tmpdir4 } from "os";
 import { gunzipSync } from "zlib";
 import {
@@ -8471,11 +8923,11 @@ async function installFromMarketplace(pluginsDir, slug, options) {
   const plugin = detailData.data;
   const name = options?.name || String(plugin.slug || slug);
   const targetDir = resolve7(pluginsDir, name);
-  if (existsSync9(targetDir) && !options?.force) {
+  if (existsSync11(targetDir) && !options?.force) {
     throw new Error(`Plugin "${name}" already exists. Use --force to overwrite.`);
   }
   mkdirSync7(targetDir, { recursive: true });
-  const tmpDir = join10(tmpdir4(), `xbrowser-marketplace-${Date.now()}`);
+  const tmpDir = join12(tmpdir4(), `xbrowser-marketplace-${Date.now()}`);
   mkdirSync7(tmpDir, { recursive: true });
   const realSlug = String(plugin.slug || slug);
   try {
@@ -8506,7 +8958,7 @@ function isManifestArray(data) {
   return Array.isArray(data) && data.length > 0 && typeof data[0].path === "string" && typeof data[0].content === "string";
 }
 function extractManifestToDir(manifest, targetDir) {
-  if (existsSync9(targetDir)) {
+  if (existsSync11(targetDir)) {
     rmSync5(targetDir, { recursive: true, force: true });
   }
   mkdirSync7(targetDir, { recursive: true });
@@ -8538,18 +8990,18 @@ async function downloadAndExtractMarketplaceTarball(baseUrl, slug, tmpDir, targe
   }
   if (tarballRes.status === 302 || tarballRes.headers.get("location")) {
     const redirectUrl = tarballRes.headers.get("location");
-    const tarballPath = join10(tmpDir, `${slug}.tar.gz`);
+    const tarballPath = join12(tmpDir, `${slug}.tar.gz`);
     await downloadToFile3(redirectUrl, tarballPath);
-    const buffer = readFileSync7(tarballPath);
+    const buffer = readFileSync9(tarballPath);
     const manifest = tryParseAsGzippedManifest(buffer);
     if (manifest) {
       extractManifestToDir(manifest, targetDir);
       return;
     }
-    const extractDir = join10(tmpDir, "extracted");
+    const extractDir = join12(tmpDir, "extracted");
     extractTarGz3(tarballPath, extractDir);
     flattenPackageRoot3(extractDir);
-    if (existsSync9(targetDir)) {
+    if (existsSync11(targetDir)) {
       rmSync5(targetDir, { recursive: true, force: true });
     }
     cpSync5(extractDir, targetDir, { recursive: true, force: true });
@@ -8560,13 +9012,13 @@ async function downloadAndExtractMarketplaceTarball(baseUrl, slug, tmpDir, targe
       extractManifestToDir(manifest, targetDir);
       return;
     }
-    const tarballPath = join10(tmpDir, `${slug}.tar.gz`);
+    const tarballPath = join12(tmpDir, `${slug}.tar.gz`);
     writeFileSync9(tarballPath, buffer);
     try {
-      const extractDir = join10(tmpDir, "extracted");
+      const extractDir = join12(tmpDir, "extracted");
       extractTarGz3(tarballPath, extractDir);
       flattenPackageRoot3(extractDir);
-      if (existsSync9(targetDir)) {
+      if (existsSync11(targetDir)) {
         rmSync5(targetDir, { recursive: true, force: true });
       }
       cpSync5(extractDir, targetDir, { recursive: true, force: true });
@@ -8602,11 +9054,11 @@ function writeMarketplacePackageJson(plugin, slug, name, baseUrl, targetDir) {
     }
   };
   const pkgPath = resolve7(targetDir, "package.json");
-  if (!existsSync9(pkgPath)) {
+  if (!existsSync11(pkgPath)) {
     writeFileSync9(pkgPath, JSON.stringify(packageJson, null, 2));
   } else {
     try {
-      const existing = JSON.parse(readFileSync7(pkgPath, "utf-8"));
+      const existing = JSON.parse(readFileSync9(pkgPath, "utf-8"));
       const merged = {
         ...existing,
         xbrowser: { ...existing.xbrowser, ...packageJson.xbrowser },
@@ -8619,7 +9071,7 @@ function writeMarketplacePackageJson(plugin, slug, name, baseUrl, targetDir) {
   }
 }
 function ensureIndexFile(plugin, name, targetDir) {
-  if (!existsSync9(resolve7(targetDir, "index.ts")) && !existsSync9(resolve7(targetDir, "index.js"))) {
+  if (!existsSync11(resolve7(targetDir, "index.ts")) && !existsSync11(resolve7(targetDir, "index.js"))) {
     const commands = plugin.commands || [];
     const commandHandlers = commands.length > 0 ? commands.map((cmd) => {
       return [
@@ -8673,7 +9125,7 @@ var PluginInstaller = class {
     const type = this.detectSourceType(source);
     const name = options?.name || this.deriveName(source, type);
     const targetDir = resolve8(this.pluginsDir, name);
-    if (existsSync10(targetDir) && !options?.force) {
+    if (existsSync12(targetDir) && !options?.force) {
       throw new Error(`Plugin "${name}" already exists. Use --force to overwrite.`);
     }
     mkdirSync8(targetDir, { recursive: true });
@@ -8716,10 +9168,10 @@ var PluginInstaller = class {
    */
   async fixSharedDeps(pluginDir) {
     const indexPath = resolve8(pluginDir, "index.ts");
-    if (!existsSync10(indexPath)) return;
+    if (!existsSync12(indexPath)) return;
     let content;
     try {
-      content = readFileSync8(indexPath, "utf8");
+      content = readFileSync10(indexPath, "utf8");
     } catch {
       return;
     }
@@ -8734,7 +9186,7 @@ var PluginInstaller = class {
     const toCopy = [];
     for (const file of missingFiles) {
       const targetPath = resolve8(sharedDir, file);
-      if (!existsSync10(targetPath)) {
+      if (!existsSync12(targetPath)) {
         toCopy.push(file);
       }
     }
@@ -8745,7 +9197,7 @@ var PluginInstaller = class {
     ];
     let sourceSharedDir = null;
     for (const dir of repoSharedDirs) {
-      if (existsSync10(dir)) {
+      if (existsSync12(dir)) {
         sourceSharedDir = dir;
         break;
       }
@@ -8762,7 +9214,7 @@ var PluginInstaller = class {
             const content2 = await resp.text();
             const dst = resolve8(sharedDir, file);
             const dstDir = dirname4(dst);
-            if (!existsSync10(dstDir)) mkdirSync8(dstDir, { recursive: true });
+            if (!existsSync12(dstDir)) mkdirSync8(dstDir, { recursive: true });
             writeFileSync10(dst, content2, "utf-8");
             console.log(`\u2705 Downloaded shared/${file} from GitHub`);
           } else {
@@ -8784,7 +9236,7 @@ var PluginInstaller = class {
     for (const file of toCopy) {
       const src = resolve8(sourceSharedDir, file);
       const dst = resolve8(sharedDir, file);
-      if (existsSync10(src)) {
+      if (existsSync12(src)) {
         try {
           cpSync6(dirname4(src), dirname4(dst), { recursive: true });
           console.log(`\u2705 Copied shared/${file} for plugin "${basename2(pluginDir)}"`);
@@ -8834,7 +9286,7 @@ var PluginInstaller = class {
    */
   async uninstall(name) {
     const targetDir = resolve8(this.pluginsDir, name);
-    if (!existsSync10(targetDir)) {
+    if (!existsSync12(targetDir)) {
       throw new Error(`Plugin "${name}" not found`);
     }
     rmSync6(targetDir, { recursive: true, force: true });
@@ -8845,7 +9297,7 @@ var PluginInstaller = class {
    * @returns Array of installed plugin information.
    */
   async list(_options) {
-    if (!existsSync10(this.pluginsDir)) return [];
+    if (!existsSync12(this.pluginsDir)) return [];
     const entries = readdirSync2(this.pluginsDir, { withFileTypes: true });
     const plugins = [];
     for (const entry of entries) {
@@ -8853,7 +9305,7 @@ var PluginInstaller = class {
       const pluginPath = resolve8(this.pluginsDir, entry.name);
       const indexPath = resolve8(pluginPath, "index.ts");
       const indexJsPath = resolve8(pluginPath, "index.js");
-      if (!existsSync10(indexPath) && !existsSync10(indexJsPath)) continue;
+      if (!existsSync12(indexPath) && !existsSync12(indexJsPath)) continue;
       const metadata = PluginMetadataParser.parseFromPackageJson(pluginPath);
       let source = "local";
       const pkg = readJsonFile(resolve8(pluginPath, "package.json"), {});
@@ -8880,10 +9332,10 @@ var PluginInstaller = class {
     }
     if (source.startsWith("file://")) {
       const filePath = decodeURIComponent(new URL(source).pathname);
-      if (existsSync10(filePath)) return "url";
+      if (existsSync12(filePath)) return "url";
     }
     if (source.endsWith(".git") || source.includes("github.com/")) return "git";
-    if (existsSync10(resolve8(source))) return "local";
+    if (existsSync12(resolve8(source))) return "local";
     return "npm";
   }
   deriveName(source, type) {
@@ -9812,7 +10264,7 @@ var previewBuiltin = {
 
 // src/builtins/knowledge.ts
 init_site_knowledge();
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 var knowledgeBuiltin = {
   name: "knowledge",
   description: "View LLM-readable site knowledge base (selectors, forms, APIs)",
@@ -9991,8 +10443,8 @@ var knowledgeBuiltin = {
       }
       const mdPath = getKnowledgePath(domain, "md");
       const jsonPath = getKnowledgePath(domain, "json");
-      console.log(`Markdown: ${mdPath} (${existsSync12(mdPath) ? "exists" : "not found"})`);
-      console.log(`JSON:     ${jsonPath} (${existsSync12(jsonPath) ? "exists" : "not found"})`);
+      console.log(`Markdown: ${mdPath} (${existsSync14(mdPath) ? "exists" : "not found"})`);
+      console.log(`JSON:     ${jsonPath} (${existsSync14(jsonPath) ? "exists" : "not found"})`);
       return;
     }
     console.error(`Unknown subcommand: ${subcommand}`);
@@ -10274,6 +10726,12 @@ async function handleBrowserCommand(command, args, options, sessionName, mode, c
           output: options.output || options.o || args[0]
         };
         break;
+      case "ua": {
+        cmdName = "ua";
+        const val = args.join(" ").trim() || options.value || "";
+        params = { value: val };
+        break;
+      }
       case "eval": {
         cmdName = "eval";
         const frameVal = options.frame || void 0;
@@ -10582,14 +11040,14 @@ async function handleBrowserCommand(command, args, options, sessionName, mode, c
 
 // src/cli/session-routes.ts
 import { homedir as homedir8 } from "os";
-import { join as join12 } from "path";
+import { join as join14 } from "path";
 import { readdirSync as readdirSync3, rmSync as rmSync7 } from "fs";
 function cleanSessionFiles() {
-  const dir = join12(homedir8(), ".xbrowser", "sessions");
+  const dir = join14(homedir8(), ".xbrowser", "sessions");
   let count = 0;
   try {
     for (const entry of readdirSync3(dir, { withFileTypes: true })) {
-      const p = join12(dir, entry.name);
+      const p = join14(dir, entry.name);
       rmSync7(p, { recursive: true, force: true });
       count++;
     }
@@ -10993,7 +11451,7 @@ async function handlePlugin(args, options, mode) {
       } catch {
       }
       try {
-        const { daemonPing } = await import("./daemon-client-Y2YSZCGK.js");
+        const { daemonPing } = await import("./daemon-client-HEGAXWGK.js");
         if (await daemonPing()) {
           await fetch("http://localhost:9224/rpc", {
             method: "POST",
@@ -11143,7 +11601,7 @@ function handleDaemon(args, options, mode) {
 }
 
 // src/cli/record-routes.ts
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 async function handleRecord(args, options, mode) {
   const sub = args[0];
   switch (sub) {
@@ -11174,9 +11632,9 @@ async function handleRecord(args, options, mode) {
         outputError(String(result.error || "Failed to stop recording"));
         return;
       }
-      if (output && !existsSync13(output)) {
+      if (output && !existsSync15(output)) {
         const defaultRecording = SessionRecorder.getRecordingsDir(sessionName) + "/recording.json";
-        if (existsSync13(defaultRecording)) {
+        if (existsSync15(defaultRecording)) {
           try {
             const { mkdirSync: mkdirSync11, copyFileSync: copyFileSync2 } = await import("fs");
             const { dirname: pathDirname } = await import("path");
@@ -11562,7 +12020,7 @@ async function handleGeneratePlugin(sessionName, pluginName, outputDir) {
   const { SessionRecorder: SessionRecorder2 } = await import("./session-recorder-SLDBENVF.js");
   const { readSiteKnowledge: readSiteKnowledge2, toMarkdown } = await import("./site-knowledge-SYC6VCDB.js");
   const { mkdirSync: mkdirSync11, writeFileSync: writeFileSync13 } = await import("fs");
-  const { join: join14 } = await import("path");
+  const { join: join16 } = await import("path");
   const data = SessionRecorder2.readData(sessionName);
   if (!data) {
     outputError(`No recording found for session "${sessionName}". Run \`xbrowser record stop --session ${sessionName}\` first.`);
@@ -11574,14 +12032,14 @@ async function handleGeneratePlugin(sessionName, pluginName, outputDir) {
   } catch {
   }
   const finalPluginName = pluginName || domain.split(".")[0] || "my-site";
-  const finalOutputDir = outputDir || join14(process.cwd(), ".xcli", "plugins", finalPluginName);
+  const finalOutputDir = outputDir || join16(process.cwd(), ".xcli", "plugins", finalPluginName);
   const knowledge = readSiteKnowledge2(domain);
   const knowledgeMd = knowledge ? toMarkdown(knowledge) : "";
   const pluginCode = generatePluginCode(finalPluginName, domain, data, knowledgeMd);
-  mkdirSync11(join14(finalOutputDir), { recursive: true });
-  writeFileSync13(join14(finalOutputDir, "index.ts"), pluginCode, "utf-8");
+  mkdirSync11(join16(finalOutputDir), { recursive: true });
+  writeFileSync13(join16(finalOutputDir, "index.ts"), pluginCode, "utf-8");
   if (knowledgeMd) {
-    writeFileSync13(join14(finalOutputDir, "SITE_KNOWLEDGE.md"), knowledgeMd, "utf-8");
+    writeFileSync13(join16(finalOutputDir, "SITE_KNOWLEDGE.md"), knowledgeMd, "utf-8");
   }
   console.log("");
   console.log("=== Plugin Generated ===");
@@ -12124,7 +12582,7 @@ async function handleNetCommand(args, options, mode, sessionName) {
 
 // src/cli/test-routes.ts
 import { execSync as execSync3 } from "child_process";
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync11 } from "fs";
 import { resolve as resolve9 } from "path";
 function findPluginPath(plugin) {
   const candidates = [
@@ -12133,7 +12591,7 @@ function findPluginPath(plugin) {
   ];
   for (const p of candidates) {
     try {
-      readFileSync9(p, "utf-8");
+      readFileSync11(p, "utf-8");
       return p;
     } catch {
     }
@@ -12144,7 +12602,7 @@ function extractSchema(plugin, command) {
   const pluginPath = findPluginPath(plugin);
   let src;
   try {
-    src = readFileSync9(pluginPath, "utf-8");
+    src = readFileSync11(pluginPath, "utf-8");
   } catch {
     return null;
   }
@@ -13067,7 +13525,7 @@ function extractSessionNameFromArgv(argv) {
 async function handleEvalMode(argv) {
   const evalCommands = parseEvalFlags(argv);
   if (evalCommands.length === 0) return;
-  const chain = evalCommands.join(" ; ");
+  const chain = evalCommands.map((script) => `eval --script-b64 ${Buffer.from(script, "utf8").toString("base64url")}`).join(" ; ");
   const cdpEndpoint = extractCdpFromArgv(argv);
   const sessionArgIdx = argv.indexOf("--session");
   const sessionName = sessionArgIdx >= 0 && argv[sessionArgIdx + 1] ? argv[sessionArgIdx + 1] : process.env.XBROWSER_SESSION || "default";
@@ -13075,6 +13533,51 @@ async function handleEvalMode(argv) {
   printChainResult(chainResult);
   if (!chainResult.success) throw new Error("Command failed");
 }
+function findEvalStart(argv) {
+  const flagsWithValue = /* @__PURE__ */ new Set(["--session", "--cdp"]);
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "-e" || a === "--eval") return -1;
+    if (a.startsWith("--")) {
+      if (flagsWithValue.has(a)) {
+        i++;
+        continue;
+      }
+      continue;
+    }
+    return a === "eval" ? i : -1;
+  }
+  return -1;
+}
+async function handleEvalScript(parts, argv) {
+  const cdpEndpoint = extractCdpFromArgv(argv);
+  const sessionName = extractSessionNameFromArgv(argv);
+  let frame;
+  const scriptLines = [];
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (part === "--frame" && parts[i + 1]) {
+      frame = parts[i + 1];
+      i++;
+      continue;
+    }
+    if (part === "--session" || part === "--cdp") {
+      i++;
+      continue;
+    }
+    scriptLines.push(part);
+  }
+  const script = scriptLines.join("\n");
+  if (!script.trim()) {
+    console.error("Error: eval requires a script (usage: xbrowser eval <js...>)");
+    throw new Error("Command failed");
+  }
+  const b64 = Buffer.from(script, "utf8").toString("base64url");
+  const chain = frame ? `eval --frame ${frame} --script-b64 ${b64}` : `eval --script-b64 ${b64}`;
+  const chainResult = await executeChain(chain, { cdpEndpoint, sessionName });
+  printChainResult(chainResult);
+  if (!chainResult.success) throw new Error("Command failed");
+}
 async function handleChainInput(input, argv) {
   const cdpEndpoint = argv ? extractCdpFromArgv(argv) : void 0;
   const hasJson = argv ? argv.some((a) => a === "--json" || a.startsWith("--json=") || a.includes(" --json") || a.startsWith("--json")) || argv.includes("-j") : false;
@@ -13112,6 +13615,11 @@ async function routeCommand(argvIn, stdinCommands) {
       await handleStdinMode(stdinCommands, argv);
       return;
     }
+    const evalStart = findEvalStart(argv);
+    if (evalStart >= 0 && argv.length > evalStart + 1) {
+      await handleEvalScript(argv.slice(evalStart + 1), argv);
+      return;
+    }
     if (parseEvalFlags(argv).length > 0) {
       await handleEvalMode(argv);
       return;
@@ -13503,7 +14011,7 @@ Run "xbrowser ${command} ${subCommand} --help" to see available parameters.`
           }
           const needsBrowser = cmdEntry.scope === "page" || cmdEntry.scope === "browser";
           if (needsBrowser && !process.env.XBROWSER_DAEMON_WORKER) {
-            const { forwardPluginExec } = await import("./daemon-client-Y2YSZCGK.js");
+            const { forwardPluginExec } = await import("./daemon-client-HEGAXWGK.js");
             const userTimeout = typeof params.timeout === "number" && params.timeout > 0 ? params.timeout * 1e3 + 3e4 : void 0;
             const result = await forwardPluginExec(`${command}.${subCommand}`, params, sessionName, cdpEndpoint, userTimeout);
             const resultData = result && typeof result === "object" && "data" in result ? result.data : void 0;
@@ -13543,7 +14051,7 @@ Run "xbrowser ${command} ${subCommand} --help" to see available parameters.`
               const targetPage = pages[cmdTabIndex];
               await targetPage.bringToFront().catch(() => {
               });
-              const { setActivePage: setActivePage2 } = await import("./browser-V3JIWSTR.js");
+              const { setActivePage: setActivePage2 } = await import("./browser-T7OVLAEC.js");
               setActivePage2(session, targetPage);
             }
           }
@@ -15116,12 +15624,12 @@ var FileListHandler = class {
     const msg = ctx.message;
     try {
       const { readdirSync: readdirSync4, statSync } = await import("fs");
-      const { join: join14, resolve: resolve10 } = await import("path");
+      const { join: join16, resolve: resolve10 } = await import("path");
       const targetPath = resolve10(msg.path);
       const entries = readdirSync4(targetPath);
       const files = entries.map((name) => {
         try {
-          const stat = statSync(join14(targetPath, name));
+          const stat = statSync(join16(targetPath, name));
           return { name, isDir: stat.isDirectory(), size: stat.size, modified: stat.mtime.toISOString() };
         } catch {
           return { name, isDir: false, size: 0, modified: "" };
@@ -15138,10 +15646,10 @@ var FileDownloadHandler = class {
   async handle(ctx) {
     const msg = ctx.message;
     try {
-      const { readFileSync: readFileSync11 } = await import("fs");
+      const { readFileSync: readFileSync13 } = await import("fs");
       const { resolve: resolve10, basename: basename3 } = await import("path");
       const targetPath = resolve10(msg.path);
-      const data = readFileSync11(targetPath);
+      const data = readFileSync13(targetPath);
       const base64 = data.toString("base64");
       const ext = targetPath.split(".").pop()?.toLowerCase() || "";
       const mimeMap = {
@@ -16716,7 +17224,7 @@ var DataCollector = class {
     return results;
   }
   async createBrowserContext() {
-    const { launch } = await import("./cdp-driver-GD6YBBGE.js");
+    const { launch } = await import("./cdp-driver-HYCLE4YP.js");
     const { browser } = await launch({
       headless: true,
       args: ["--no-sandbox", "--disable-setuid-sandbox"]
@@ -16756,7 +17264,7 @@ var DataCollector = class {
 
 // src/cdp-interceptor/index.ts
 async function createCDPInterceptor(config) {
-  const { CDPInterceptorProxy: CDPInterceptorProxy2 } = await import("./proxy-C6CK3UH5.js");
+  const { CDPInterceptorProxy: CDPInterceptorProxy2 } = await import("./proxy-LUR4U5YF.js");
   const proxy = new CDPInterceptorProxy2(config);
   await proxy.start();
   return proxy;