@xbrowser/cli 1.11.0 → 1.13.0

package/dist/daemon-main.js

@@ -20,7 +20,6 @@ import {
   closeEphemeralContext,
   closeSessionByName,
   createEphemeralContext,
-  createRuleEngine,
   createSession,
   findOrRestoreSession,
   findSession,
@@ -31,8 +30,10 @@ import {
   resolveLaunchOpts,
   saveSessionDiskMeta,
   setActivePage
-} from "./chunk-HVPUVVSA.js";
-import "./chunk-XQ4HRPDJ.js";
+} from "./chunk-HD4FX2N5.js";
+import {
+  createRuleEngine
+} from "./chunk-T2CNKWPV.js";
 import {
   queryJS
 } from "./chunk-3FWLW7FS.js";
@@ -45,18 +46,19 @@ import {
   formatDetectionMessage
 } from "./chunk-JKVUFP3G.js";
 import {
-  ScreencastCapturer
-} from "./chunk-BNO7OKO4.js";
+  ScreencastCapturer,
+  resolveScreenshotsDir
+} from "./chunk-HBMEFSTB.js";
 import "./chunk-KFQGP6VL.js";
 
 // src/daemon/daemon-main.ts
 import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, appendFileSync, unlinkSync } from "fs";
-import { join as join7 } from "path";
+import { join as join9 } from "path";
 import { homedir as homedir7 } from "os";
 import { startHttpServer } from "@dyyz1993/xcli-core";
 
 // src/daemon/rpc-handlers.ts
-import { readFileSync as readFileSync5 } from "fs";
+import { readFileSync as readFileSync7 } from "fs";
 import {
   createSessionMeta,
   removeSession
@@ -64,8 +66,8 @@ import {
 
 // src/executor.ts
 import {
-  ok as ok25,
-  fail as fail11,
+  ok as ok28,
+  fail as fail13,
   isCommandResult,
   CompositeStorage as CompositeStorage2,
   TipCollector as TipCollector2,
@@ -922,29 +924,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}`]);
     }
@@ -952,37 +1366,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) {
@@ -997,38 +1439,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 = {};
@@ -1038,9 +1480,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)}`);
     }
   }
 });
@@ -1048,11 +1490,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(
@@ -1061,9 +1503,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)}`);
     }
   }
 });
@@ -1071,26 +1513,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);
@@ -1106,30 +1546,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) => {
@@ -1147,21 +1587,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
@@ -1170,7 +1610,7 @@ var screenshotCommand = registerCommand({
     ensureScreenshotsDir();
     const screenshotPath = generateScreenshotPath(format);
     writeFileSync(screenshotPath, buffer, "binary");
-    return ok9({
+    return ok12({
       output: screenshotPath,
       format,
       size: buffer.length
@@ -1179,19 +1619,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(
@@ -1223,30 +1663,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();
@@ -1259,7 +1699,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 },
@@ -1270,17 +1710,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) => {
@@ -1291,21 +1731,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;
@@ -1316,12 +1756,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()
     });
@@ -1329,27 +1769,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;
@@ -1431,7 +1871,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,
@@ -1447,23 +1887,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;
@@ -1545,7 +1985,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,
@@ -1567,17 +2007,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;
@@ -1639,7 +2079,7 @@ var perfCheckCommand = registerCommand({
       if (resourceStats) avg.resourceStats = resourceStats;
       return avg;
     })();
-    return ok13({
+    return ok16({
       url: page.url(),
       iterations: p.iterations,
       metrics: avgMetrics,
@@ -1653,23 +2093,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;
@@ -1756,7 +2196,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,
@@ -1771,68 +2211,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,
@@ -1923,11 +2361,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" });
@@ -1947,14 +2385,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,
@@ -1964,8 +2402,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";
@@ -2350,15 +2788,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));
@@ -2366,7 +2804,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++) {
@@ -2436,7 +2874,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) => ({
@@ -2449,9 +2887,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) {
@@ -2510,7 +2948,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) {
@@ -2520,20 +2958,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([
@@ -2768,21 +3206,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,
@@ -2793,7 +3231,7 @@ var mapCommand = registerCommand({
         verbose: p.verbose
       });
       const linkObjects = links.map((url) => ({ url }));
-      return ok16({
+      return ok19({
         links: linkObjects,
         success: true
       });
@@ -2801,15 +3239,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);
@@ -2986,21 +3424,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);
@@ -3139,7 +3577,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(() => {
@@ -3149,15 +3587,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) {
@@ -3491,16 +3929,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));
@@ -3606,7 +4044,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})`, ""];
@@ -3616,9 +4054,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);
     }
@@ -3626,8 +4064,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);
@@ -3725,19 +4163,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();
@@ -3792,7 +4230,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 = [];
@@ -3819,7 +4257,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,
@@ -3833,9 +4271,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 {
@@ -3890,7 +4328,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,
@@ -3904,9 +4342,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);
     }
@@ -3914,7 +4352,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",
@@ -4168,11 +4606,11 @@ 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);
 
 // 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();
@@ -4413,8 +4851,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";
@@ -4492,10 +4930,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 {
@@ -4509,9 +4947,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: {} };
     }
@@ -4531,16 +4969,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;
   }
@@ -5084,24 +5522,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;
@@ -5115,7 +5553,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"`
       ]));
     }
@@ -5123,15 +5561,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([
@@ -5141,9 +5579,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) {
@@ -5220,22 +5658,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, {
@@ -5244,7 +5682,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`
     ]));
   }
@@ -5254,14 +5692,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"
   }),
@@ -5275,7 +5713,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({
@@ -5283,16 +5721,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"
   }),
@@ -5306,30 +5744,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) {
@@ -5342,7 +5780,7 @@ var tabCommand = registerCommand({
       case "switch":
         return handleSwitch(p, pages, ctx);
       default:
-        return fail9(`Unknown subcommand: ${p.subcommand}`);
+        return fail11(`Unknown subcommand: ${p.subcommand}`);
     }
   }
 });
@@ -5357,7 +5795,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();
@@ -5385,7 +5823,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,
@@ -5396,11 +5834,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;
@@ -5415,7 +5853,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)
@@ -5423,10 +5861,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(() => {
@@ -5436,13 +5874,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,
@@ -5451,9 +5895,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";
@@ -5593,14 +6037,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) {
@@ -5608,7 +6052,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;
@@ -5634,14 +6078,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) {
@@ -5650,20 +6094,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);
@@ -5671,45 +6115,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;
@@ -5724,7 +6168,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);
@@ -5736,15 +6180,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") {
@@ -5758,7 +6202,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;
 }
@@ -6469,7 +6913,7 @@ async function loadHooks() {
 
 // src/executor.ts
 import { homedir as homedir5 } from "os";
-import { join as join5 } from "path";
+import { join as join7 } 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));
@@ -6484,7 +6928,7 @@ function levenshtein(a, b) {
 }
 var NAVIGATION_COMMANDS = /* @__PURE__ */ new Set(["goto", "back", "forward", "refresh"]);
 var snapshotHintShown = /* @__PURE__ */ new WeakSet();
-var CONFIG_DIR2 = join5(homedir5(), ".xbrowser");
+var CONFIG_DIR2 = join7(homedir5(), ".xbrowser");
 var storageCache = /* @__PURE__ */ new Map();
 function getPluginStorage(pluginName) {
   if (!storageCache.has(pluginName)) {
@@ -6496,7 +6940,7 @@ var archiveInitialized = false;
 function ensureArchiveInit() {
   if (!archiveInitialized) {
     try {
-      configureArchiveStore({ archiveDir: join5(homedir5(), ".xbrowser", "archives") });
+      configureArchiveStore({ archiveDir: join7(homedir5(), ".xbrowser", "archives") });
     } catch {
     }
     archiveInitialized = true;
@@ -6520,7 +6964,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 [];
@@ -6597,7 +7041,7 @@ async function executeCommand(commandName, params, sessionName = "default", extr
   }
   let targetPageOverride = null;
   if (_target && extraOpts?.cdpEndpoint) {
-    const { findTargetPage } = await import("./browser-XNU7JQYC.js");
+    const { findTargetPage } = await import("./browser-AQ2AT2YZ.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.`);
@@ -6614,8 +7058,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-MMDRYCF5.js");
-    const result = await forwardExec(commandName, params, sessionName, extraOpts?.cdpEndpoint);
+    const { forwardExec } = await import("./daemon-client-7D6EZNOE.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;
@@ -6783,7 +7234,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 } : {} };
     }
@@ -6797,14 +7248,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-EF33LKRJ.js");
+        const { attemptRecovery } = await import("./recovery-Z3RDZENA.js");
         const recovery = await attemptRecovery(
           session.page,
           sessionName,
@@ -6842,7 +7293,7 @@ async function executeCommand(commandName, params, sessionName = "default", extr
       duration,
       timestamp: start
     });
-    return { ...fail11(errorMessage), duration };
+    return { ...fail13(errorMessage), duration };
   } finally {
   }
 }
@@ -6883,7 +7334,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") {
@@ -6902,7 +7353,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") {
@@ -7006,7 +7457,7 @@ async function executeChain(input, options) {
             results.push({
               command: `${cmdName} ${subCommand}`,
               raw: cmdStr,
-              ...ok25(data),
+              ...ok28(data),
               duration: duration2,
               ...hookOutputs ? { hookOutputs } : {}
             });
@@ -7034,7 +7485,7 @@ async function executeChain(input, options) {
             results.push({
               command: `${cmdName} ${subCommand}`,
               raw: cmdStr,
-              ...fail11(errorMessage),
+              ...fail13(errorMessage),
               duration: duration2
             });
             if (type === "and") {
@@ -7338,10 +7789,10 @@ async function replayEntry(entry, options = {}) {
 }
 
 // src/daemon/feedback-store.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "fs";
-import { join as join6 } from "path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "fs";
+import { join as join8 } from "path";
 import { homedir as homedir6 } from "os";
-var FEEDBACK_FILE = join6(homedir6(), ".xbrowser", "feedback.json");
+var FEEDBACK_FILE = join8(homedir6(), ".xbrowser", "feedback.json");
 var FeedbackStore = class {
   entries = [];
   constructor() {
@@ -7349,7 +7800,7 @@ var FeedbackStore = class {
   }
   load() {
     try {
-      const data = readFileSync3(FEEDBACK_FILE, "utf8");
+      const data = readFileSync5(FEEDBACK_FILE, "utf8");
       this.entries = JSON.parse(data);
     } catch {
       this.entries = [];
@@ -7357,7 +7808,7 @@ var FeedbackStore = class {
   }
   save() {
     try {
-      mkdirSync4(join6(homedir6(), ".xbrowser"), { recursive: true });
+      mkdirSync4(join8(homedir6(), ".xbrowser"), { recursive: true });
       writeFileSync4(FEEDBACK_FILE, JSON.stringify(this.entries, null, 2));
     } catch {
     }
@@ -7841,7 +8292,7 @@ function createRPCHandler() {
       return result;
     } catch (err) {
       const errorMessage = errMsg(err);
-      const { attemptRecovery } = await import("./recovery-EF33LKRJ.js");
+      const { attemptRecovery } = await import("./recovery-Z3RDZENA.js");
       const recovery = await attemptRecovery(
         session?.page,
         sessionName,
@@ -8381,7 +8832,7 @@ function createRPCHandler() {
     let rawContent;
     let parsed;
     try {
-      rawContent = readFileSync5(file, "utf8");
+      rawContent = readFileSync7(file, "utf8");
       try {
         parsed = JSON.parse(rawContent);
       } catch {
@@ -8406,7 +8857,7 @@ function createRPCHandler() {
     if (isNewFormat) {
       try {
         const replayErrors = [];
-        const { SessionReplayer } = await import("./session-replayer-WIUYVN5J.js");
+        const { SessionReplayer } = await import("./session-replayer-UVH5FGY2.js");
         const replayer = new SessionReplayer({
           page: session.page,
           stepDelay: slowMo * 500,
@@ -8456,10 +8907,10 @@ function createRPCHandler() {
     const errors = Array.isArray(input.errors) ? input.errors : [];
     const eventsPlayed = typeof input.eventsPlayed === "number" ? input.eventsPlayed : 0;
     const totalEvents = typeof input.totalEvents === "number" ? input.totalEvents : eventsPlayed + errors.length;
-    const ok26 = input.ok ?? errors.length === 0;
+    const ok29 = input.ok ?? errors.length === 0;
     return {
-      ok: ok26,
-      success: ok26,
+      ok: ok29,
+      success: ok29,
       duration: typeof input.duration === "number" ? input.duration : 0,
       eventsPlayed,
       totalEvents,
@@ -9458,12 +9909,12 @@ var FileListHandler = class {
     const msg = ctx.message;
     try {
       const { readdirSync, statSync } = await import("fs");
-      const { join: join8, resolve } = await import("path");
+      const { join: join10, resolve } = await import("path");
       const targetPath = resolve(msg.path);
       const entries = readdirSync(targetPath);
       const files = entries.map((name) => {
         try {
-          const stat = statSync(join8(targetPath, name));
+          const stat = statSync(join10(targetPath, name));
           return { name, isDir: stat.isDirectory(), size: stat.size, modified: stat.mtime.toISOString() };
         } catch {
           return { name, isDir: false, size: 0, modified: "" };
@@ -9480,10 +9931,10 @@ var FileDownloadHandler = class {
   async handle(ctx) {
     const msg = ctx.message;
     try {
-      const { readFileSync: readFileSync6 } = await import("fs");
+      const { readFileSync: readFileSync8 } = await import("fs");
       const { resolve, basename } = await import("path");
       const targetPath = resolve(msg.path);
-      const data = readFileSync6(targetPath);
+      const data = readFileSync8(targetPath);
       const base64 = data.toString("base64");
       const ext = targetPath.split(".").pop()?.toLowerCase() || "";
       const mimeMap = {
@@ -11473,8 +11924,8 @@ connectWS();
 }
 
 // src/daemon/daemon-main.ts
-var CONFIG_DIR3 = join7(homedir7(), ".xbrowser");
-var LOG_FILE = join7(CONFIG_DIR3, "daemon.log");
+var CONFIG_DIR3 = join9(homedir7(), ".xbrowser");
+var LOG_FILE = join9(CONFIG_DIR3, "daemon.log");
 function log(msg) {
   const ts = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").substring(0, 19);
   const line = `[DAEMON ${ts}] ${msg}
@@ -11506,7 +11957,7 @@ async function main() {
     if (err.code === "EADDRINUSE") {
       log(`Port ${daemonPort} already in use \u2014 another daemon instance likely won the startup race. Exiting gracefully.`);
       try {
-        unlinkSync(join7(CONFIG_DIR3, "daemon.json"));
+        unlinkSync(join9(CONFIG_DIR3, "daemon.json"));
       } catch {
       }
       process.exit(0);
@@ -11548,7 +11999,7 @@ async function main() {
     });
   });
   mkdirSync5(CONFIG_DIR3, { recursive: true });
-  writeFileSync5(join7(CONFIG_DIR3, "daemon.json"), JSON.stringify({
+  writeFileSync5(join9(CONFIG_DIR3, "daemon.json"), JSON.stringify({
     port: daemonPort,
     pid: process.pid,
     startedAt: Date.now()