@xbrowser/cli 1.24.2 → 1.25.0

package/dist/daemon-main.js

@@ -102,8 +102,8 @@ function classifyFailure(message) {
 
 // src/executor.ts
 import {
-  ok as ok30,
-  fail as fail15,
+  ok as ok31,
+  fail as fail16,
   isCommandResult,
   CompositeStorage as CompositeStorage2,
   TipCollector as TipCollector2,
@@ -1449,37 +1449,109 @@ var uaCommand = registerCommand({
   }
 });
 
-// src/commands/storage.ts
+// src/commands/preflight.ts
 import { z as z11 } from "zod";
 import { ok as ok11, fail as fail4 } from "@dyyz1993/xcli-core";
+var preflightCommand = registerCommand({
+  name: "preflight",
+  description: "Pre-flight anti-bot gate: open local detection page and verify stealth posture before any automation task",
+  scope: "page",
+  parameters: z11.object({
+    strict: z11.boolean().optional().describe("\u5931\u8D25\u65F6\u4EE5\u975E\u96F6\u9000\u51FA\u7801\u7ED3\u675F\uFF08\u94FE\u5F0F/CI \u95E8\u7981\u7528\uFF09"),
+    publish: z11.boolean().optional().describe("\u53D1\u5E03\u7C7B\u4EFB\u52A1\u95E8\u7981\uFF1Aheadless \u73AF\u5883\u76F4\u63A5\u5224\u5931\u8D25\uFF08\u9ED8\u8BA4\u7531 XBROWSER_NO_HEADLESS_PUBLISH \u63A7\u5236\uFF09")
+  }),
+  result: z11.object({
+    gate: z11.enum(["pass", "fail"]),
+    failed: z11.array(z11.string()),
+    headless: z11.boolean()
+  }),
+  handler: async (p, ctx) => {
+    const page = ctx.page;
+    const tips = [];
+    const ua = await page.evaluate("navigator.userAgent").catch(() => "");
+    const outerW = await page.evaluate("window.outerWidth").catch(() => 0);
+    const headless = /headless/i.test(ua) || outerW === 0;
+    const publishMode = p.publish || process.env.XBROWSER_NO_HEADLESS_PUBLISH === "1";
+    if (publishMode && headless) {
+      tips.push("\u53D1\u5E03\u7C7B\u4EFB\u52A1\u7981\u7528 headless\uFF08\u98CE\u63A7\u7EA2\u7EBF\uFF09\uFF1A\u63A5\u6709\u5934\u771F\u6D4F\u89C8\u5668\u540E\u91CD\u8BD5");
+      tips.push('  \u6709\u5934 Chrome: "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" --user-data-dir=~/.xbrowser/chrome-profile-headed --remote-debugging-port=9222');
+      tips.push("  \u7136\u540E\u52A0 --cdp http://localhost:9222");
+      return fail4("PREFLIGHT-FAIL: headless \u4E0D\u5141\u8BB8\u7528\u4E8E\u53D1\u5E03\u7C7B\u4EFB\u52A1\uFF08\u7528 --cdp \u63A5\u6709\u5934 Chrome\uFF09", tips);
+    }
+    let pageUrl = null;
+    try {
+      const { fileURLToPath } = await import("url");
+      const { join: join10, dirname: dirname3 } = await import("path");
+      const { existsSync: existsSync4 } = await import("fs");
+      const here = typeof __filename !== "undefined" ? __filename : fileURLToPath(import.meta.url);
+      const candidates = [
+        join10(dirname3(here), "..", "assets", "preflight.html"),
+        join10(process.cwd(), "assets", "preflight.html")
+      ];
+      pageUrl = candidates.find((c) => existsSync4(c)) || null;
+    } catch {
+    }
+    if (pageUrl) {
+      await page.goto("file://" + pageUrl, { waitUntil: "domcontentloaded", timeout: 15e3 });
+    } else {
+      await page.goto("about:blank");
+      await page.evaluate(`(function(){
+				var fails=[];
+				if(navigator.webdriver!==false)fails.push('webdriver');
+				if(/headless/i.test(navigator.userAgent))fails.push('ua-no-headless');
+				window.__pf=fails.join(',');
+				document.title=fails.length?'PREFLIGHT-FAIL':'PREFLIGHT-PASS';
+			})()`);
+    }
+    await page.waitForTimeout(1200);
+    const result = await page.evaluate(`(function(){
+			var out=document.getElementById('out');
+			return { title: document.title, fails: out ? (out.getAttribute('data-fails')||'') : (window.__pf||'') };
+		})()`).catch(() => ({ title: "PREFLIGHT-FAIL", fails: "evaluate-error" }));
+    const passed = result.title === "PREFLIGHT-PASS";
+    const failed = result.fails ? result.fails.split(",").filter(Boolean) : [];
+    tips.push(`headless=${headless}${publishMode ? "\uFF08publish \u95E8\u7981\u5F00\u542F\uFF09" : ""}`);
+    if (passed) {
+      tips.push("\u9884\u68C0\u901A\u8FC7\uFF1A\u53CD\u722C\u59FF\u6001\u5168\u90E8\u65AD\u8A00\u7EFF\u706F\uFF0C\u53EF\u6267\u884C\u81EA\u52A8\u5316\u4EFB\u52A1");
+      return ok11({ gate: "pass", failed: [], headless }, tips);
+    }
+    tips.push(`\u5931\u8D25\u9879: ${failed.join(", ") || result.title}`);
+    tips.push("\u4FEE\u590D\u6307\u5F15: headless \u73AF\u5883\u63A5\u6709\u5934 Chrome\uFF08--cdp\uFF09\uFF1Bwebdriver \u6CC4\u6F0F\u68C0\u67E5 stealth \u57AB\u7247\uFF08XBROWSER_STEALTH \u4E0D\u4E3A off\uFF09");
+    return fail4(`PREFLIGHT-FAIL: ${failed.join(", ") || result.title}`, tips);
+  }
+});
+
+// src/commands/storage.ts
+import { z as z12 } from "zod";
+import { ok as ok12, fail as fail5 } from "@dyyz1993/xcli-core";
 var getCookiesCommand = registerCommand({
   name: "get-cookies",
   description: "Get all cookies for the current page",
   scope: "page",
-  result: z11.object({
-    cookies: z11.array(z11.record(z11.unknown()))
+  result: z12.object({
+    cookies: z12.array(z12.record(z12.unknown()))
   }),
   handler: async (_p, ctx) => {
     const cookies = await ctx.browserContext.cookies();
-    return ok11({ cookies });
+    return ok12({ cookies });
   }
 });
 var setCookieCommand = registerCommand({
   name: "set-cookie",
   description: "Set a cookie",
   scope: "page",
-  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()
+  parameters: z12.object({
+    name: z12.coerce.string(),
+    value: z12.coerce.string(),
+    domain: z12.coerce.string().optional(),
+    path: z12.coerce.string().optional(),
+    url: z12.string().optional().describe("Cookie URL (alternative to domain)"),
+    expires: z12.number().optional(),
+    httpOnly: z12.boolean().optional(),
+    secure: z12.boolean().optional(),
+    sameSite: z12.enum(["Strict", "Lax", "None"]).optional()
   }),
-  result: z11.object({ name: z11.string() }),
+  result: z12.object({ name: z12.string() }),
   handler: async (p, ctx) => {
     const cookie = { ...p };
     if (!cookie.domain && !cookie.url) {
@@ -1494,38 +1566,38 @@ var setCookieCommand = registerCommand({
       }
     }
     if (!cookie.domain && !cookie.url) {
-      return fail4("set-cookie requires --domain or --url, or a non-blank page URL to infer from");
+      return fail5("set-cookie requires --domain or --url, or a non-blank page URL to infer from");
     }
     await ctx.browserContext.addCookies([cookie]);
-    return ok11({ name: p.name });
+    return ok12({ name: p.name });
   }
 });
 var clearCookiesCommand = registerCommand({
   name: "clear-cookies",
   description: "Clear all cookies",
   scope: "page",
-  result: z11.object({ cleared: z11.boolean() }),
+  result: z12.object({ cleared: z12.boolean() }),
   handler: async (_p, ctx) => {
     await ctx.browserContext.clearCookies();
-    return ok11({ cleared: true });
+    return ok12({ cleared: true });
   }
 });
 var getLocalStorageCommand = registerCommand({
   name: "get-local-storage",
   description: "Get localStorage entries",
   scope: "page",
-  parameters: z11.object({
-    key: z11.string().optional()
+  parameters: z12.object({
+    key: z12.string().optional()
   }),
-  result: z11.union([
-    z11.object({ key: z11.string(), value: z11.string().nullable() }),
-    z11.object({ data: z11.record(z11.string()) })
+  result: z12.union([
+    z12.object({ key: z12.string(), value: z12.string().nullable() }),
+    z12.object({ data: z12.record(z12.string()) })
   ]),
   handler: async (p, ctx) => {
     try {
       if (p.key) {
         const value = await ctx.page.evaluate((k) => localStorage.getItem(k), p.key);
-        return ok11({ key: p.key, value });
+        return ok12({ key: p.key, value });
       }
       const data = await ctx.page.evaluate(() => {
         const entries = {};
@@ -1535,9 +1607,9 @@ var getLocalStorageCommand = registerCommand({
         }
         return entries;
       });
-      return ok11({ data });
+      return ok12({ data });
     } catch (e) {
-      return fail4(`localStorage not accessible on this page: ${e instanceof Error ? e.message : String(e)}`);
+      return fail5(`localStorage not accessible on this page: ${e instanceof Error ? e.message : String(e)}`);
     }
   }
 });
@@ -1545,11 +1617,11 @@ var setLocalStorageCommand = registerCommand({
   name: "set-local-storage",
   description: "Set a localStorage entry",
   scope: "page",
-  parameters: z11.object({
-    key: z11.string(),
-    value: z11.string()
+  parameters: z12.object({
+    key: z12.string(),
+    value: z12.string()
   }),
-  result: z11.object({ key: z11.string() }),
+  result: z12.object({ key: z12.string() }),
   handler: async (p, ctx) => {
     try {
       await ctx.page.evaluate(
@@ -1558,9 +1630,9 @@ var setLocalStorageCommand = registerCommand({
         },
         { key: p.key, value: p.value }
       );
-      return ok11({ key: p.key });
+      return ok12({ key: p.key });
     } catch (e) {
-      return fail4(`localStorage not accessible on this page: ${e instanceof Error ? e.message : String(e)}`);
+      return fail5(`localStorage not accessible on this page: ${e instanceof Error ? e.message : String(e)}`);
     }
   }
 });
@@ -1568,20 +1640,20 @@ var clearLocalStorageCommand = registerCommand({
   name: "clear-local-storage",
   description: "Clear all localStorage entries",
   scope: "page",
-  result: z11.object({ cleared: z11.boolean() }),
+  result: z12.object({ cleared: z12.boolean() }),
   handler: async (_p, ctx) => {
     try {
       await ctx.page.evaluate(() => localStorage.clear());
-      return ok11({ cleared: true });
+      return ok12({ cleared: true });
     } catch (e) {
-      return fail4(`localStorage not accessible on this page: ${e instanceof Error ? e.message : String(e)}`);
+      return fail5(`localStorage not accessible on this page: ${e instanceof Error ? e.message : String(e)}`);
     }
   }
 });
 
 // src/commands/screenshot.ts
-import { z as z12 } from "zod";
-import { ok as ok12, fail as fail5 } from "@dyyz1993/xcli-core";
+import { z as z13 } from "zod";
+import { ok as ok13, fail as fail6 } from "@dyyz1993/xcli-core";
 import { writeFileSync, mkdirSync } from "fs";
 import { dirname, join as join4 } from "path";
 function ensureScreenshotsDir() {
@@ -1608,23 +1680,23 @@ var screenshotCommand = registerCommand({
   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: 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")
+  parameters: z13.object({
+    selector: z13.string().optional(),
+    type: z13.enum(["png", "jpeg"]).optional(),
+    fullPage: z13.boolean().optional(),
+    output: z13.string().optional(),
+    base64: z13.boolean().optional().describe("Return base64 data instead of file path")
   }),
-  result: z12.union([
-    z12.object({
-      data: z12.string(),
-      format: z12.string(),
-      size: z12.number()
+  result: z13.union([
+    z13.object({
+      data: z13.string(),
+      format: z13.string(),
+      size: z13.number()
     }),
-    z12.object({
-      output: z12.string(),
-      format: z12.string(),
-      size: z12.number()
+    z13.object({
+      output: z13.string(),
+      format: z13.string(),
+      size: z13.number()
     })
   ]),
   handler: async (p, ctx) => {
@@ -1642,21 +1714,21 @@ var screenshotCommand = registerCommand({
     if (p.output) {
       const dirErr = ensureParentDir(p.output);
       if (dirErr) {
-        return fail5(`Cannot create directory for --output "${p.output}": ${dirErr}`);
+        return fail6(`Cannot create directory for --output "${p.output}": ${dirErr}`);
       }
       try {
         writeFileSync(p.output, buffer, "binary");
       } catch (err) {
-        return fail5(`Failed to write screenshot to "${p.output}": ${err instanceof Error ? err.message : String(err)}`);
+        return fail6(`Failed to write screenshot to "${p.output}": ${err instanceof Error ? err.message : String(err)}`);
       }
-      return ok12({
+      return ok13({
         output: p.output,
         format,
         size: buffer.length
       });
     }
     if (p.base64) {
-      return ok12({
+      return ok13({
         data: buffer.toString("base64"),
         format,
         size: buffer.length
@@ -1665,7 +1737,7 @@ var screenshotCommand = registerCommand({
     ensureScreenshotsDir();
     const screenshotPath = generateScreenshotPath(format);
     writeFileSync(screenshotPath, buffer, "binary");
-    return ok12({
+    return ok13({
       output: screenshotPath,
       format,
       size: buffer.length
@@ -1674,19 +1746,19 @@ var screenshotCommand = registerCommand({
 });
 
 // src/commands/structure.ts
-import { z as z13 } from "zod";
-import { ok as ok13 } from "@dyyz1993/xcli-core";
+import { z as z14 } from "zod";
+import { ok as ok14 } 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: z13.object({
-    selector: z13.string().optional(),
-    depth: z13.number().optional()
+  parameters: z14.object({
+    selector: z14.string().optional(),
+    depth: z14.number().optional()
   }),
-  result: z13.object({
-    structure: z13.record(z13.unknown())
+  result: z14.object({
+    structure: z14.record(z14.unknown())
   }),
   handler: async (p, ctx) => {
     const structure = await ctx.page.evaluate(
@@ -1718,30 +1790,30 @@ var structureCommand = registerCommand({
       },
       { sel: p.selector || "body", maxDepth: p.depth || 5 }
     );
-    return ok13({ structure });
+    return ok14({ structure });
   }
 });
 
 // src/commands/viewport.ts
-import { z as z14 } from "zod";
-import { ok as ok14 } from "@dyyz1993/xcli-core";
+import { z as z15 } from "zod";
+import { ok as ok15 } from "@dyyz1993/xcli-core";
 var setViewportCommand = registerCommand({
   name: "set-viewport",
   description: "Set the viewport size and properties",
   scope: "browser",
-  parameters: z14.object({
-    width: z14.coerce.number(),
-    height: z14.coerce.number(),
-    deviceScaleFactor: z14.coerce.number().optional(),
-    isMobile: z14.boolean().optional(),
-    hasTouch: z14.boolean().optional()
+  parameters: z15.object({
+    width: z15.coerce.number(),
+    height: z15.coerce.number(),
+    deviceScaleFactor: z15.coerce.number().optional(),
+    isMobile: z15.boolean().optional(),
+    hasTouch: z15.boolean().optional()
   }),
-  result: z14.object({
-    width: z14.number(),
-    height: z14.number(),
-    deviceScaleFactor: z14.number().optional(),
-    isMobile: z14.boolean().optional(),
-    hasTouch: z14.boolean().optional()
+  result: z15.object({
+    width: z15.number(),
+    height: z15.number(),
+    deviceScaleFactor: z15.number().optional(),
+    isMobile: z15.boolean().optional(),
+    hasTouch: z15.boolean().optional()
   }),
   handler: async (p, ctx) => {
     const viewport = ctx.page.viewportSize();
@@ -1754,7 +1826,7 @@ var setViewportCommand = registerCommand({
       ...p.isMobile !== void 0 && { isMobile: p.isMobile },
       ...p.hasTouch !== void 0 && { hasTouch: p.hasTouch }
     });
-    return ok14({
+    return ok15({
       width,
       height,
       ...p.deviceScaleFactor !== void 0 && { deviceScaleFactor: p.deviceScaleFactor },
@@ -1765,17 +1837,17 @@ var setViewportCommand = registerCommand({
 });
 
 // src/commands/frame.ts
-import { z as z15 } from "zod";
-import { ok as ok15, fail as fail6 } from "@dyyz1993/xcli-core";
+import { z as z16 } from "zod";
+import { ok as ok16, fail as fail7 } from "@dyyz1993/xcli-core";
 var framesCommand = registerCommand({
   name: "frames",
   description: "List all frames in the current page",
   scope: "page",
-  result: z15.object({
-    frames: z15.array(z15.object({
-      index: z15.number(),
-      name: z15.string().nullable(),
-      url: z15.string()
+  result: z16.object({
+    frames: z16.array(z16.object({
+      index: z16.number(),
+      name: z16.string().nullable(),
+      url: z16.string()
     }))
   }),
   handler: async (_p, ctx) => {
@@ -1786,21 +1858,21 @@ var framesCommand = registerCommand({
       name: frame.name(),
       url: frame.url()
     }));
-    return ok15({ frames: frameList });
+    return ok16({ frames: frameList });
   }
 });
 var frameCommand = registerCommand({
   name: "frame",
   description: "Get frame info by index or name",
   scope: "page",
-  parameters: z15.object({
-    index: z15.number().int().min(0).optional(),
-    name: z15.string().optional()
+  parameters: z16.object({
+    index: z16.number().int().min(0).optional(),
+    name: z16.string().optional()
   }),
-  result: z15.object({
-    name: z15.string().nullable(),
-    url: z15.string(),
-    error: z15.string().optional()
+  result: z16.object({
+    name: z16.string().nullable(),
+    url: z16.string(),
+    error: z16.string().optional()
   }),
   handler: async (p, ctx) => {
     const discover = ctx.page.discoverFrames;
@@ -1811,12 +1883,12 @@ var frameCommand = registerCommand({
     } else if (p.name !== void 0) {
       targetFrame = rawFrames.find((f) => f.name() === p.name);
     } else {
-      return fail6("Must provide index or name");
+      return fail7("Must provide index or name");
     }
     if (!targetFrame) {
-      return fail6("Frame not found");
+      return fail7("Frame not found");
     }
-    return ok15({
+    return ok16({
       name: targetFrame.name(),
       url: targetFrame.url()
     });
@@ -1824,27 +1896,27 @@ var frameCommand = registerCommand({
 });
 
 // src/commands/ui-debug.ts
-import { z as z16 } from "zod";
-import { ok as ok16 } from "@dyyz1993/xcli-core";
+import { z as z17 } from "zod";
+import { ok as ok17 } from "@dyyz1993/xcli-core";
 var consoleCheckCommand = registerCommand({
   name: "console",
   description: "Collect and analyze browser console messages (errors, warnings, logs)",
   scope: "page",
-  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)
+  parameters: z17.object({
+    url: z17.string().optional().describe("URL to navigate first (optional, uses current page if omitted)"),
+    duration: z17.number().optional().default(5e3).describe("How long to collect messages (ms)"),
+    filter: z17.enum(["all", "error", "warning", "info", "log"]).optional().default("all"),
+    includeStackTraces: z17.boolean().optional().default(true)
   }),
-  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()
+  result: z17.object({
+    url: z17.string(),
+    duration: z17.number(),
+    total: z17.number(),
+    errors: z17.number(),
+    warnings: z17.number(),
+    messages: z17.array(z17.record(z17.unknown())),
+    summary: z17.string(),
+    passed: z17.boolean()
   }),
   handler: async (p, ctx) => {
     const { page } = ctx;
@@ -1926,7 +1998,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 ok16({
+    return ok17({
       url: page.url(),
       duration: p.duration,
       total: messages.length,
@@ -1942,23 +2014,23 @@ var networkCheckCommand = registerCommand({
   name: "net-debug",
   description: "Monitor and analyze network requests \u2014 capture failed requests, slow responses, status codes",
   scope: "page",
-  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)')
+  parameters: z17.object({
+    url: z17.string().optional().describe("URL to navigate first"),
+    duration: z17.number().optional().default(5e3).describe("How long to monitor (ms)"),
+    filter: z17.enum(["all", "failed", "slow", "error", "xhr", "fetch", "document", "stylesheet", "script", "image"]).optional().default("all"),
+    slowThreshold: z17.number().optional().default(3e3).describe('Threshold for "slow" requests (ms)')
   }),
-  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()
+  result: z17.object({
+    url: z17.string(),
+    duration: z17.number(),
+    totalRequests: z17.number(),
+    failedRequests: z17.number(),
+    slowRequests: z17.number(),
+    errorRequests: z17.number(),
+    totalSizeKB: z17.number(),
+    requests: z17.array(z17.record(z17.unknown())),
+    summary: z17.string(),
+    passed: z17.boolean()
   }),
   handler: async (p, ctx) => {
     const { page } = ctx;
@@ -2040,7 +2112,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 ok16({
+      return ok17({
         url: page.url(),
         duration: p.duration,
         totalRequests: requests.length,
@@ -2062,17 +2134,17 @@ var perfCheckCommand = registerCommand({
   name: "perf",
   description: "Audit page performance metrics \u2014 load time, FCP, LCP, CLS, TTFB, resource sizes",
   scope: "page",
-  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")
+  parameters: z17.object({
+    url: z17.string().optional().describe("URL to navigate (uses current page if omitted)"),
+    iterations: z17.number().optional().default(1).describe("Number of iterations to average")
   }),
-  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()
+  result: z17.object({
+    url: z17.string(),
+    iterations: z17.number(),
+    metrics: z17.record(z17.unknown()),
+    allIterations: z17.array(z17.record(z17.unknown())).optional(),
+    passed: z17.boolean(),
+    summary: z17.string()
   }),
   handler: async (p, ctx) => {
     const { page } = ctx;
@@ -2134,7 +2206,7 @@ var perfCheckCommand = registerCommand({
       if (resourceStats) avg.resourceStats = resourceStats;
       return avg;
     })();
-    return ok16({
+    return ok17({
       url: page.url(),
       iterations: p.iterations,
       metrics: avgMetrics,
@@ -2148,23 +2220,23 @@ var healthCheckCommand = registerCommand({
   name: "health",
   description: "Comprehensive page health check \u2014 broken links, missing images, console errors, SEO issues",
   scope: "page",
-  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")
+  parameters: z17.object({
+    url: z17.string().optional().describe("URL to check"),
+    checkLinks: z17.boolean().optional().default(true).describe("Check for broken links"),
+    checkImages: z17.boolean().optional().default(true).describe("Check for missing/broken images"),
+    checkMeta: z17.boolean().optional().default(true).describe("Check SEO meta tags"),
+    maxLinks: z17.number().optional().default(50).describe("Max links to check")
   }),
-  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()
+  result: z17.object({
+    url: z17.string(),
+    title: z17.string(),
+    passed: z17.boolean(),
+    totalIssues: z17.number(),
+    errors: z17.number(),
+    warnings: z17.number(),
+    info: z17.number(),
+    issues: z17.array(z17.record(z17.unknown())),
+    summary: z17.string()
   }),
   handler: async (p, ctx) => {
     const { page } = ctx;
@@ -2251,7 +2323,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 ok16({
+    return ok17({
       url: result.url,
       title: result.title,
       passed: errors === 0,
@@ -2266,8 +2338,8 @@ var healthCheckCommand = registerCommand({
 });
 
 // src/commands/actions.ts
-import { z as z17 } from "zod";
-import { ok as ok17 } from "@dyyz1993/xcli-core";
+import { z as z18 } from "zod";
+import { ok as ok18 } from "@dyyz1993/xcli-core";
 import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
 import { join as join5 } from "path";
 function ensureScreenshotsDir2() {
@@ -2279,53 +2351,53 @@ function generateScreenshotPath2(format) {
   const ext = format === "jpeg" ? "jpg" : "png";
   return join5(resolveScreenshotsDir(), `screenshot-${timestamp}-${random}.${ext}`);
 }
-var waitActionSchema = z17.object({
-  type: z17.literal("wait"),
-  milliseconds: z17.number().positive().optional(),
-  selector: z17.string().optional()
+var waitActionSchema = z18.object({
+  type: z18.literal("wait"),
+  milliseconds: z18.number().positive().optional(),
+  selector: z18.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 = z17.object({
-  type: z17.literal("click"),
-  selector: z17.string(),
-  all: z17.boolean().optional()
+var clickActionSchema = z18.object({
+  type: z18.literal("click"),
+  selector: z18.string(),
+  all: z18.boolean().optional()
 });
-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 screenshotActionSchema = z18.object({
+  type: z18.literal("screenshot"),
+  fullPage: z18.boolean().optional(),
+  quality: z18.number().min(1).max(100).optional(),
+  viewport: z18.object({ width: z18.number().int().positive(), height: z18.number().int().positive() }).optional(),
+  base64: z18.boolean().optional().describe("Return base64 data instead of file path")
 });
-var writeActionSchema = z17.object({
-  type: z17.literal("write"),
-  text: z17.string()
+var writeActionSchema = z18.object({
+  type: z18.literal("write"),
+  text: z18.string()
 });
-var pressActionSchema = z17.object({
-  type: z17.literal("press"),
-  key: z17.string()
+var pressActionSchema = z18.object({
+  type: z18.literal("press"),
+  key: z18.string()
 });
-var scrollActionSchema = z17.object({
-  type: z17.literal("scroll"),
-  direction: z17.enum(["up", "down"]).optional(),
-  selector: z17.string().optional()
+var scrollActionSchema = z18.object({
+  type: z18.literal("scroll"),
+  direction: z18.enum(["up", "down"]).optional(),
+  selector: z18.string().optional()
 });
-var scrapeActionSchema = z17.object({
-  type: z17.literal("scrape")
+var scrapeActionSchema = z18.object({
+  type: z18.literal("scrape")
 });
-var executeJavascriptActionSchema = z17.object({
-  type: z17.literal("executeJavascript"),
-  script: z17.string()
+var executeJavascriptActionSchema = z18.object({
+  type: z18.literal("executeJavascript"),
+  script: z18.string()
 });
-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 pdfActionSchema = z18.object({
+  type: z18.literal("pdf"),
+  landscape: z18.boolean().optional(),
+  scale: z18.number().optional(),
+  format: z18.enum(["A0", "A1", "A2", "A3", "A4", "A5", "A6", "Letter", "Legal", "Tabloid", "Ledger"]).optional()
 });
-var actionSchema = z17.union([
+var actionSchema = z18.union([
   waitActionSchema,
   clickActionSchema,
   screenshotActionSchema,
@@ -2416,11 +2488,11 @@ var actionsCommand = registerCommand({
   name: "actions",
   description: "Execute a sequence of actions (wait, click, scroll, screenshot, fill, etc.)",
   scope: "page",
-  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)")
+  parameters: z18.object({
+    url: z18.string().describe("Starting URL"),
+    actions: z18.array(actionSchema).max(MAX_ACTIONS).describe("Array of actions (max 50)"),
+    output: z18.enum(["text", "json"]).default("json").describe("Output format: text or json"),
+    timeout: z18.number().default(60).describe("Overall timeout in seconds (default: 60)")
   }),
   handler: async (p, ctx) => {
     await ctx.page.goto(p.url, { waitUntil: "domcontentloaded" });
@@ -2440,14 +2512,14 @@ var actionsCommand = registerCommand({
     const finalUrl = ctx.page.url();
     const timedOut = results.length < p.actions.length;
     if (p.output === "text") {
-      return ok17({
+      return ok18({
         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 ok17({
+    return ok18({
       title,
       url: finalUrl,
       results,
@@ -2457,8 +2529,8 @@ var actionsCommand = registerCommand({
 });
 
 // src/commands/scrape.ts
-import { z as z18 } from "zod";
-import { ok as ok18, fail as fail7 } from "@dyyz1993/xcli-core";
+import { z as z19 } from "zod";
+import { ok as ok19, fail as fail8 } from "@dyyz1993/xcli-core";
 
 // src/lib/html-to-markdown.ts
 import * as cheerio from "cheerio";
@@ -2843,15 +2915,15 @@ var scrapeCommand = registerCommand({
   description: "Scrape a page and convert to Markdown (with JS rendering)",
   scope: "project",
   selectorParams: ["selector"],
-  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")
+  parameters: z19.object({
+    url: z19.string().optional(),
+    selector: z19.string().optional(),
+    timeout: z19.number().default(3e4),
+    format: z19.enum(["markdown", "html", "text"]).default("markdown"),
+    onlyMainContent: z19.boolean().default(true),
+    retries: z19.number().int().min(0).max(5).optional().default(2).describe("\u91CD\u8BD5\u6B21\u6570\uFF08\u9ED8\u8BA4 2\uFF09"),
+    waitAfterLoad: z19.number().int().optional().default(0).describe("\u9875\u9762\u52A0\u8F7D\u540E\u989D\u5916\u7B49\u5F85\u6BEB\u79D2"),
+    mode: z19.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));
@@ -2859,7 +2931,7 @@ var scrapeCommand = registerCommand({
     try {
       const targetUrl = p.url || page.url();
       if (!targetUrl || targetUrl === "about:blank") {
-        return fail7("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.");
       }
       let lastError;
       for (let attempt = 1; attempt <= maxAttempts; attempt++) {
@@ -2929,7 +3001,7 @@ var scrapeCommand = registerCommand({
             } catch {
             }
             if (p.mode === "smart") {
-              return ok18(structured);
+              return ok19(structured);
             }
             if (p.mode === "compact") {
               const compactData = structured.tables.length > 0 ? structured.tables.map((t) => ({
@@ -2942,9 +3014,9 @@ var scrapeCommand = registerCommand({
                   return compact;
                 })
               })) : structured.mainText?.substring(0, 500);
-              return ok18({ url: structured.url, title: structured.title, data: compactData });
+              return ok19({ url: structured.url, title: structured.title, data: compactData });
             }
-            return ok18(structured);
+            return ok19(structured);
           }
           let content;
           switch (p.format) {
@@ -3003,7 +3075,7 @@ var scrapeCommand = registerCommand({
               content = await page.innerText("body");
               break;
           }
-          return ok18({ content, title, url: finalUrl });
+          return ok19({ content, title, url: finalUrl });
         } catch (err) {
           lastError = err instanceof Error ? err : new Error(String(err));
           if (attempt < maxAttempts) {
@@ -3013,20 +3085,20 @@ var scrapeCommand = registerCommand({
           }
         }
       }
-      return fail7(`Scrape failed after ${maxAttempts} attempt(s): ${lastError?.message ?? "unknown error"}`);
+      return fail8(`Scrape failed after ${maxAttempts} attempt(s): ${lastError?.message ?? "unknown error"}`);
     } finally {
       await closeEphemeralContext(context);
     }
   },
-  result: z18.object({
-    url: z18.string(),
-    title: z18.string()
+  result: z19.object({
+    url: z19.string(),
+    title: z19.string()
   }).passthrough()
 });
 
 // src/commands/map.ts
-import { z as z19 } from "zod";
-import { ok as ok19, fail as fail8 } from "@dyyz1993/xcli-core";
+import { z as z20 } from "zod";
+import { ok as ok20, fail as fail9 } from "@dyyz1993/xcli-core";
 
 // src/utils/url.ts
 var SKIP_EXTENSIONS = /* @__PURE__ */ new Set([
@@ -3261,21 +3333,21 @@ var mapCommand = registerCommand({
   name: "map",
   description: "Discover all URLs on a website via sitemap and page link extraction",
   scope: "project",
-  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")
+  parameters: z20.object({
+    url: z20.string().optional(),
+    search: z20.string().optional(),
+    sitemap: z20.enum(["include", "only"]).optional(),
+    includeSubdomains: z20.boolean().optional(),
+    allowExternalLinks: z20.boolean().optional().describe("Include links to external domains"),
+    limit: z20.number().optional(),
+    verbose: z20.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 fail8("URL is required. Provide a URL or connect to a browser (--cdp) with a non-blank page.");
+        return fail9("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,
@@ -3286,7 +3358,7 @@ var mapCommand = registerCommand({
         verbose: p.verbose
       });
       const linkObjects = links.map((url) => ({ url }));
-      return ok19({
+      return ok20({
         links: linkObjects,
         success: true
       });
@@ -3294,15 +3366,15 @@ var mapCommand = registerCommand({
       await closeEphemeralContext(context);
     }
   },
-  result: z19.object({
-    links: z19.array(z19.object({ url: z19.string() })),
-    success: z19.boolean()
+  result: z20.object({
+    links: z20.array(z20.object({ url: z20.string() })),
+    success: z20.boolean()
   })
 });
 
 // src/commands/crawl.ts
-import { z as z20 } from "zod";
-import { ok as ok20 } from "@dyyz1993/xcli-core";
+import { z as z21 } from "zod";
+import { ok as ok21 } from "@dyyz1993/xcli-core";
 function stripHashAnchorQuery(url) {
   try {
     const parsed = new URL(url);
@@ -3479,21 +3551,21 @@ var crawlCommand = registerCommand({
   name: "crawl",
   description: "Crawl a website and extract content from all pages",
   scope: "project",
-  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)
+  parameters: z21.object({
+    url: z21.string(),
+    limit: z21.number().default(10),
+    maxDepth: z21.number().default(3),
+    includePaths: z21.array(z21.string()).optional(),
+    excludePaths: z21.array(z21.string()).optional(),
+    allowSubdomains: z21.boolean().default(false),
+    allowExternalLinks: z21.boolean().default(false),
+    allowBackwardCrawling: z21.boolean().default(false),
+    enableSpa: z21.boolean().default(true).describe("Disable to skip SPA route detection"),
+    format: z21.enum(["markdown", "html"]).default("markdown"),
+    onlyMainContent: z21.boolean().default(true),
+    concurrency: z21.number().default(3),
+    retries: z21.number().default(2),
+    verbose: z21.boolean().default(false)
   }),
   handler: async (p, ctx) => {
     const startUrl = new URL(p.url);
@@ -3632,7 +3704,7 @@ var crawlCommand = registerCommand({
         if (errorPages.length > 0) {
           response.errors = errorPages;
         }
-        return ok20(response);
+        return ok21(response);
       } finally {
         for (const ctx2 of contexts) {
           await ctx2.close().catch(() => {
@@ -3642,15 +3714,15 @@ var crawlCommand = registerCommand({
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       const successPages = results.filter((r) => !isPageError(r));
-      return ok20({ pages: successPages, total: successPages.length, success: false, error: message });
+      return ok21({ pages: successPages, total: successPages.length, success: false, error: message });
     }
   }
 });
 
 // src/commands/search.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 import * as cheerio2 from "cheerio";
-import { ok as ok21 } from "@dyyz1993/xcli-core";
+import { ok as ok22 } from "@dyyz1993/xcli-core";
 function getRecencyParams(recency) {
   const now = Math.floor(Date.now() / 1e3);
   switch (recency) {
@@ -3984,16 +4056,16 @@ var searchCommand = registerCommand({
   name: "search",
   description: "Search the web and extract results with engine fallback",
   scope: "project",
-  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)")
+  parameters: z22.object({
+    query: z22.string(),
+    engine: z22.string().optional(),
+    limit: z22.number().default(10),
+    full: z22.boolean().default(false),
+    format: z22.enum(["markdown", "json", "text"]).default("markdown"),
+    timeout: z22.number().default(15e3),
+    recency: z22.enum(["hour", "day", "week", "month", "year"]).optional().describe("Filter by time: hour/day/week/month/year"),
+    fallback: z22.boolean().default(false).describe("Sequential engine fallback instead of parallel"),
+    site: z22.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));
@@ -4099,7 +4171,7 @@ ${errors.map((e) => `  - ${e.engine}: ${e.error}`).join("\n")}`
           lines.push(`> ${r.snippet}`);
           lines.push("");
         }
-        return ok21({ ...searchResult, content: lines.join("\n") });
+        return ok22({ ...searchResult, content: lines.join("\n") });
       }
       if (p.format === "text") {
         const lines = [`Search: ${searchResult.query} (Engine: ${searchResult.engine}, Total: ${searchResult.total})`, ""];
@@ -4109,9 +4181,9 @@ ${errors.map((e) => `  - ${e.engine}: ${e.error}`).join("\n")}`
           lines.push(`   ${r.snippet}`);
           lines.push("");
         }
-        return ok21({ ...searchResult, content: lines.join("\n") });
+        return ok22({ ...searchResult, content: lines.join("\n") });
       }
-      return ok21(searchResult);
+      return ok22(searchResult);
     } finally {
       await closeEphemeralContext(context);
     }
@@ -4119,8 +4191,8 @@ ${errors.map((e) => `  - ${e.engine}: ${e.error}`).join("\n")}`
 });
 
 // src/commands/network.ts
-import { z as z22 } from "zod";
-import { ok as ok22, fail as fail9 } from "@dyyz1993/xcli-core";
+import { z as z23 } from "zod";
+import { ok as ok23, fail as fail10 } from "@dyyz1993/xcli-core";
 function extractPath2(url) {
   try {
     const u = new URL(url);
@@ -4218,19 +4290,19 @@ var networkCommand = registerCommand({
   name: "network",
   description: "Capture and filter network responses from a URL",
   scope: "project",
-  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")
+  parameters: z23.object({
+    url: z23.string(),
+    filter: z23.string().optional(),
+    match: z23.string().optional(),
+    search: z23.string().optional().describe("Search within all captured response bodies"),
+    console: z23.boolean().default(false),
+    timeout: z23.number().default(3e4),
+    wait: z23.number().default(3e3),
+    limit: z23.number().default(50),
+    format: z23.enum(["summary", "json"]).default("summary"),
+    ws: z23.boolean().optional().default(false).describe("Only show WebSocket messages"),
+    listen: z23.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: z23.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();
@@ -4285,7 +4357,7 @@ var networkCommand = registerCommand({
     };
     if (p.listen) {
       const page2 = ctx.page;
-      if (!page2) return fail9("No active page. Use --cdp to connect first.");
+      if (!page2) return fail10("No active page. Use --cdp to connect first.");
       const captures = [];
       const consoleMessages = [];
       const wsCaptures = [];
@@ -4312,7 +4384,7 @@ var networkCommand = registerCommand({
       page2.off("response", handler);
       const duration = Date.now() - startTime;
       if (p.ws && wsCaptures.length > 0) {
-        return ok22({
+        return ok23({
           url: "[listen mode]",
           duration,
           total: captures.length,
@@ -4326,9 +4398,9 @@ var networkCommand = registerCommand({
         });
       }
       if (p.format === "json") {
-        return ok22(buildJsonOutput("[listen mode]", captures, consoleMessages, captures.length, wsCaptures));
+        return ok23(buildJsonOutput("[listen mode]", captures, consoleMessages, captures.length, wsCaptures));
       }
-      return ok22(buildSummaryOutput("[listen mode]", duration, captures, consoleMessages, captures.length, wsCaptures));
+      return ok23(buildSummaryOutput("[listen mode]", duration, captures, consoleMessages, captures.length, wsCaptures));
     }
     const { context, page } = await createEphemeralContext(resolveLaunchOpts(ctx));
     try {
@@ -4383,7 +4455,7 @@ var networkCommand = registerCommand({
       }
       const duration = Date.now() - startTime;
       if (p.ws && wsCaptures.length > 0) {
-        return ok22({
+        return ok23({
           url: p.url,
           duration,
           total: captures.length,
@@ -4397,9 +4469,9 @@ var networkCommand = registerCommand({
         });
       }
       if (p.format === "json") {
-        return ok22(buildJsonOutput(p.url, results, consoleMessages, totalCount, wsCaptures, searchResults));
+        return ok23(buildJsonOutput(p.url, results, consoleMessages, totalCount, wsCaptures, searchResults));
       }
-      return ok22(buildSummaryOutput(p.url, duration, results, consoleMessages, totalCount, wsCaptures));
+      return ok23(buildSummaryOutput(p.url, duration, results, consoleMessages, totalCount, wsCaptures));
     } finally {
       await closeEphemeralContext(context);
     }
@@ -4407,7 +4479,7 @@ var networkCommand = registerCommand({
 });
 
 // src/commands/ai-search-engines.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 var ENGINE_CONFIGS = {
   deepseek: {
     key: "deepseek",
@@ -4661,11 +4733,11 @@ var ENGINE_CONFIGS = {
   }
 };
 var ALL_ENGINE_KEYS = Object.keys(ENGINE_CONFIGS);
-var ENGINE_KEY_ENUM = z23.enum(ALL_ENGINE_KEYS);
+var ENGINE_KEY_ENUM = z24.enum(ALL_ENGINE_KEYS);
 
 // src/commands/snapshot.ts
-import { z as z24 } from "zod";
-import { ok as ok23, fail as fail10, normalizeTips as normalizeTips3 } from "@dyyz1993/xcli-core";
+import { z as z25 } from "zod";
+import { ok as ok24, fail as fail11, normalizeTips as normalizeTips3 } from "@dyyz1993/xcli-core";
 
 // src/runtime/ref-store.ts
 var sessions = /* @__PURE__ */ new Map();
@@ -5577,24 +5649,24 @@ var snapshotCommand = registerCommand({
   description: "Capture a quick page state snapshot \u2014 aria tree, visible text, or DOM summary",
   scope: "page",
   selectorParams: ["selector"],
-  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")
+  parameters: z25.object({
+    type: z25.enum(["aria", "text", "dom", "all"]).default("aria").describe("Snapshot type: aria (accessibility tree), text (visible text), dom (element summary), all (combined)"),
+    selector: z25.string().optional().describe("Scope to a specific element"),
+    depth: z25.number().optional().default(6).describe("Max depth for DOM/aria tree"),
+    interactive: z25.boolean().optional().default(false).describe("Return interactive agent refs only"),
+    interactiveOnly: z25.boolean().optional().default(false).describe("Alias for interactive"),
+    i: z25.boolean().optional().default(false).describe("Short alias for interactive"),
+    compact: z25.boolean().optional().default(false).describe("Include compact xbrowser style snapshot text"),
+    c: z25.boolean().optional().default(false).describe("Short alias for compact"),
+    selectors: z25.boolean().optional().default(false).describe("Include ref to CSS selector map"),
+    all: z25.boolean().optional().default(false).describe("Include hidden interactive targets when using interactive snapshot")
   }),
-  result: z24.object({
-    url: z24.string(),
-    title: z24.string(),
-    aria: z24.string().optional(),
-    text: z24.string().optional(),
-    dom: z24.record(z24.unknown()).optional()
+  result: z25.object({
+    url: z25.string(),
+    title: z25.string(),
+    aria: z25.string().optional(),
+    text: z25.string().optional(),
+    dom: z25.record(z25.unknown()).optional()
   }),
   handler: async (p, ctx) => {
     const page = ctx.page;
@@ -5608,7 +5680,7 @@ var snapshotCommand = registerCommand({
       if (p.compact || p.c || p.interactive || p.interactiveOnly || p.i) {
         observation.compact = formatObservationCompact(observation, { selectors: p.selectors });
       }
-      return ok23(observation, normalizeTips3([
+      return ok24(observation, normalizeTips3([
         `refs refreshed for ${observation.targets.length} targets; use click @e1 or fill @e2 "text"`
       ]));
     }
@@ -5616,15 +5688,15 @@ var snapshotCommand = registerCommand({
       const aria = await captureAriaSnapshot(page, p.selector, p.depth);
       const tips = await buildRefTips(page, aria);
       persistSemantics(url, aria);
-      return ok23({ url, title, aria }, normalizeTips3(tips));
+      return ok24({ url, title, aria }, normalizeTips3(tips));
     }
     if (p.type === "text") {
       const text = await captureTextSnapshot(page, p.selector);
-      return ok23({ url, title, text });
+      return ok24({ url, title, text });
     }
     if (p.type === "dom") {
       const dom = await captureDomSnapshot(page, p.selector, p.depth ?? 6);
-      return ok23({ url, title, dom });
+      return ok24({ url, title, dom });
     }
     if (p.type === "all") {
       const [aria, text, dom] = await Promise.all([
@@ -5634,9 +5706,9 @@ var snapshotCommand = registerCommand({
       ]);
       const tips = await buildRefTips(page, aria);
       persistSemantics(url, aria);
-      return ok23({ url, title, aria, text, dom }, normalizeTips3(tips));
+      return ok24({ url, title, aria, text, dom }, normalizeTips3(tips));
     }
-    return fail10(`Unknown snapshot type: ${p.type}`);
+    return fail11(`Unknown snapshot type: ${p.type}`);
   }
 });
 function persistSemantics(url, aria) {
@@ -5713,22 +5785,22 @@ async function captureDomSnapshot(page, selector, maxDepth) {
 }
 
 // src/commands/agent.ts
-import { z as z25 } from "zod";
-import { ok as ok24, normalizeTips as normalizeTips4 } from "@dyyz1993/xcli-core";
+import { z as z26 } from "zod";
+import { ok as ok25, 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: 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")
+  parameters: z26.object({
+    includeHidden: z26.boolean().optional().default(false).describe("Include hidden elements in the target list"),
+    limit: z26.number().int().positive().max(300).optional().default(80).describe("Maximum number of targets to return"),
+    compact: z26.boolean().optional().default(false).describe("Include compact xbrowser style snapshot text"),
+    selectors: z26.boolean().optional().default(false).describe("Include ref to stable CSS selector map")
   }),
-  result: z25.object({
-    targets: z25.array(z25.record(z25.unknown())),
-    selectors: z25.record(z25.unknown()).optional(),
-    compact: z25.string().optional()
+  result: z26.object({
+    targets: z26.array(z26.record(z26.unknown())),
+    selectors: z26.record(z26.unknown()).optional(),
+    compact: z26.string().optional()
   }).passthrough(),
   handler: async (p, ctx) => {
     const observation = await observePage(ctx.page, ctx.sessionId, {
@@ -5737,7 +5809,7 @@ var observeCommand = registerCommand({
     });
     if (p.selectors) observation.selectors = buildSelectorMap(observation);
     if (p.compact) observation.compact = formatObservationCompact(observation, { selectors: p.selectors });
-    return ok24(observation, normalizeTips4([
+    return ok25(observation, normalizeTips4([
       `refs refreshed for ${observation.targets.length} targets; use act --ref @e1 --action click or click @e1`
     ]));
   }
@@ -5747,14 +5819,14 @@ var actCommand = registerCommand({
   description: "Perform an agent action using an observe ref or explicit selector",
   scope: "element",
   selectorParams: ["selector"],
-  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")
+  parameters: z26.object({
+    action: z26.enum(["click", "fill", "type", "press", "select", "check", "hover"]).default("click"),
+    ref: z26.string().optional().describe("Session-scoped ref returned by observe, such as e1"),
+    selector: z26.string().optional().describe("CSS selector fallback when no ref is available"),
+    value: z26.string().optional().describe("Value for fill/type/select"),
+    key: z26.string().optional().describe("Key for press"),
+    force: z26.boolean().optional().default(false).describe("Bypass actionability checks"),
+    timeout: z26.number().optional().default(1e4).describe("Playwright action timeout in milliseconds")
   }).refine((p) => !!p.ref || !!p.selector, {
     message: "Either ref or selector is required"
   }),
@@ -5768,7 +5840,7 @@ var actCommand = registerCommand({
         tips: normalizeTips4(result.stale ? ["run observe again to refresh refs"] : [])
       };
     }
-    return ok24(result, normalizeTips4(result.stale ? ["ref screen hash changed; run observe if the next action is uncertain"] : []));
+    return ok25(result, normalizeTips4(result.stale ? ["ref screen hash changed; run observe if the next action is uncertain"] : []));
   }
 });
 var waitForCommand = registerCommand({
@@ -5776,16 +5848,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: 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)
+  parameters: z26.object({
+    selector: z26.string().optional().describe("CSS selector or observe ref to wait for"),
+    state: z26.enum(["attached", "detached", "visible", "hidden"]).optional().default("visible"),
+    text: z26.string().optional().describe("Visible text to wait for"),
+    url: z26.string().optional().describe("URL substring or glob pattern to wait for"),
+    load: z26.enum(["load", "domcontentloaded", "networkidle"]).optional().describe("Load state to wait for"),
+    fn: z26.string().optional().describe("JavaScript predicate to wait for"),
+    screenHashChanged: z26.string().optional().describe("Previous screenHash from observe"),
+    timeout: z26.number().optional().default(3e4),
+    pollInterval: z26.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"
   }),
@@ -5799,30 +5871,30 @@ var waitForCommand = registerCommand({
         tips: []
       };
     }
-    return ok24(result);
+    return ok25(result);
   }
 });
 
 // src/commands/tab.ts
-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()
+import { z as z27 } from "zod";
+import { ok as ok26, fail as fail12 } from "@dyyz1993/xcli-core";
+var TabParams = z27.object({
+  subcommand: z27.enum(["list", "new", "close", "switch"]),
+  url: z27.string().optional(),
+  index: z27.number().int().min(0).optional()
 });
 var tabCommand = registerCommand({
   name: "tab",
   description: "Manage browser tabs: list, new, close, switch",
   scope: "page",
   parameters: TabParams,
-  result: z26.object({
-    success: z26.boolean(),
-    data: z26.unknown()
+  result: z27.object({
+    success: z27.boolean(),
+    data: z27.unknown()
   }),
   handler: async (p, ctx) => {
     if (!ctx.browserContext) {
-      return fail11("No browser context available. Use --cdp to connect to a browser first.");
+      return fail12("No browser context available. Use --cdp to connect to a browser first.");
     }
     const pages = ctx.browserContext.pages();
     switch (p.subcommand) {
@@ -5835,7 +5907,7 @@ var tabCommand = registerCommand({
       case "switch":
         return handleSwitch(p, pages, ctx);
       default:
-        return fail11(`Unknown subcommand: ${p.subcommand}`);
+        return fail12(`Unknown subcommand: ${p.subcommand}`);
     }
   }
 });
@@ -5850,7 +5922,7 @@ async function handleList(pages, ctx) {
     if (isActive) activeIndex = i;
     tabs.push({ index: i, url, title, active: isActive });
   }
-  return ok25({ tabs, total: tabs.length, activeIndex });
+  return ok26({ tabs, total: tabs.length, activeIndex });
 }
 async function handleNew(p, _pages, ctx) {
   const newPage = await ctx.browserContext.newPage();
@@ -5878,7 +5950,7 @@ async function handleNew(p, _pages, ctx) {
   const title = await newPage.title().catch(() => "");
   const allPages = ctx.browserContext.pages();
   const newIndex = allPages.indexOf(newPage);
-  return ok25({
+  return ok26({
     index: newIndex >= 0 ? newIndex : allPages.length - 1,
     url: newPage.url(),
     title,
@@ -5889,11 +5961,11 @@ async function handleNew(p, _pages, ctx) {
 async function handleClose(p, ctx) {
   const currentPages = ctx.browserContext.pages();
   if (currentPages.length <= 1) {
-    return fail11("Cannot close the last remaining tab");
+    return fail12("Cannot close the last remaining tab");
   }
   const closeIndex = p.index ?? currentPages.findIndex((pg) => pg === ctx.page);
   if (closeIndex < 0 || closeIndex >= currentPages.length) {
-    return fail11(`Invalid tab index: ${closeIndex}. Valid range: 0-${currentPages.length - 1}`);
+    return fail12(`Invalid tab index: ${closeIndex}. Valid range: 0-${currentPages.length - 1}`);
   }
   const pageToClose = currentPages[closeIndex];
   const isActivePage = pageToClose === ctx.page;
@@ -5908,7 +5980,7 @@ async function handleClose(p, ctx) {
     }
     ctx.page = newActivePage;
   }
-  return ok25({
+  return ok26({
     closedIndex: closeIndex,
     total: remainingPages.length,
     activeIndex: isActivePage ? closeIndex < remainingPages.length ? closeIndex : remainingPages.length - 1 : remainingPages.findIndex((pg) => pg === ctx.page)
@@ -5916,10 +5988,10 @@ async function handleClose(p, ctx) {
 }
 async function handleSwitch(p, pages, ctx) {
   if (p.index === void 0) {
-    return fail11("Parameter --index is required for switch subcommand");
+    return fail12("Parameter --index is required for switch subcommand");
   }
   if (p.index < 0 || p.index >= pages.length) {
-    return fail11(`Invalid tab index: ${p.index}. Valid range: 0-${pages.length - 1}`);
+    return fail12(`Invalid tab index: ${p.index}. Valid range: 0-${pages.length - 1}`);
   }
   const targetPage = pages[p.index];
   await targetPage.bringToFront().catch(() => {
@@ -5941,7 +6013,7 @@ async function handleSwitch(p, pages, ctx) {
   }
   ctx.page = targetPage;
   const title = await targetPage.title().catch(() => "");
-  return ok25({
+  return ok26({
     index: p.index,
     url: targetPage.url(),
     title,
@@ -5950,8 +6022,8 @@ async function handleSwitch(p, pages, ctx) {
 }
 
 // src/commands/addinitscript.ts
-import { z as z27 } from "zod";
-import { ok as ok26 } from "@dyyz1993/xcli-core";
+import { z as z28 } from "zod";
+import { ok as ok27 } from "@dyyz1993/xcli-core";
 import { readFileSync as readFileSync4 } from "fs";
 
 // src/chain-parser.ts
@@ -6092,14 +6164,14 @@ registerCommandDefinition("tab", ["subcommand"]);
 registerCommandDefinition("mouse", ["action", "x", "y"]);
 
 // src/commands/addinitscript.ts
-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 InitScriptParams = z28.object({
+  script: z28.string().optional(),
+  file: z28.string().optional(),
+  stdin: z28.boolean().optional(),
+  name: z28.string().optional(),
+  list: z28.boolean().optional(),
+  remove: z28.union([z28.string(), z28.boolean()]).optional(),
+  base64: z28.string().optional()
 });
 var registeredScripts = /* @__PURE__ */ new Map();
 function resolveScriptContent(params) {
@@ -6133,14 +6205,14 @@ var addInitScriptCommand = registerCommand({
   description: "Add an initialization script that runs on every page load",
   scope: "page",
   parameters: InitScriptParams,
-  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()
+  result: z28.object({
+    scripts: z28.array(z28.object({ name: z28.string(), size: z28.number(), preview: z28.string() })).optional(),
+    removed: z28.string().optional(),
+    existed: z28.boolean().optional(),
+    error: z28.string().optional(),
+    registered: z28.string().optional(),
+    hint: z28.string().optional(),
+    executedImmediately: z28.boolean().optional()
   }).passthrough(),
   handler: async (params, ctx) => {
     if (params.list) {
@@ -6149,20 +6221,20 @@ var addInitScriptCommand = registerCommand({
         size: content2.length,
         preview: content2.slice(0, 80)
       }));
-      return ok26({ scripts });
+      return ok27({ scripts });
     }
     if (params.remove && typeof params.remove === "string") {
       const existed = registeredScripts.delete(params.remove);
-      return ok26({ removed: params.remove, existed });
+      return ok27({ 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 ok26({ removed: removeTarget, existed });
+      return ok27({ removed: removeTarget, existed });
     }
     let content = params.stdin ? await readStdin() : resolveScriptContent(params);
     if (!content) {
-      return ok26({ error: "No script content provided. Use --script, --file, --stdin, or --base64" });
+      return ok27({ error: "No script content provided. Use --script, --file, --stdin, or --base64" });
     }
     const scriptName = params.name ?? `script-${Date.now()}`;
     registeredScripts.set(scriptName, content);
@@ -6170,45 +6242,45 @@ var addInitScriptCommand = registerCommand({
     try {
       await ctx.page.evaluate(content);
     } catch {
-      return ok26({
+      return ok27({
         registered: scriptName,
         hint: "Script registered for future page loads; immediate execution skipped (page may not be ready)"
       });
     }
-    return ok26({ registered: scriptName, executedImmediately: true });
+    return ok27({ registered: scriptName, executedImmediately: true });
   }
 });
 registerCommandDefinition("addinitscript", ["script"]);
 
 // src/commands/find.ts
-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"]);
+import { z as z29 } from "zod";
+import { ok as ok28, fail as fail13, normalizeTips as normalizeTips5 } from "@dyyz1993/xcli-core";
+var actionSchema2 = z29.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: 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"'),
+  parameters: z29.object({
+    strategy: z29.enum(["text", "role", "label", "placeholder", "testid", "alt", "title", "first", "last", "nth"]),
+    value: z29.string(),
+    name: z29.string().optional(),
+    exact: z29.boolean().optional().default(false),
+    operation: z29.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: 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)
+    actionValue: z29.string().optional().describe("Value for fill/type/select when using action"),
+    index: z29.number().int().optional().describe("Index for nth strategy"),
+    click: z29.boolean().optional().default(false),
+    fill: z29.string().optional(),
+    type: z29.string().optional(),
+    select: z29.string().optional(),
+    hover: z29.boolean().optional().default(false),
+    check: z29.boolean().optional().default(false),
+    timeout: z29.number().optional().default(1e4)
   }),
-  result: z28.object({
-    matched: z28.number(),
-    selector: z28.string(),
-    action: z28.string().optional()
+  result: z29.object({
+    matched: z29.number(),
+    selector: z29.string(),
+    action: z29.string().optional()
   }),
   handler: async (p, ctx) => {
     const page = ctx.page;
@@ -6223,7 +6295,7 @@ var findCommand = registerCommand({
     });
     const count = await locator.count();
     if (count === 0) {
-      return fail12(`No element found with ${p.strategy}="${p.value}"`);
+      return fail13(`No element found with ${p.strategy}="${p.value}"`);
     }
     const tips = [];
     const target = selectTarget(locator, p.strategy);
@@ -6235,15 +6307,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 fail12("find fill requires a value");
+      if (actionValue === void 0) return fail13("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 fail12("find type requires a value");
+      if (actionValue === void 0) return fail13("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 fail12("find select requires a value");
+      if (actionValue === void 0) return fail13("find select requires a value");
       await target.selectOption(actionValue);
       return okWithTips({ matched: count, selector, action: `select("${actionValue}")` }, tips);
     } else if (actionName === "hover") {
@@ -6257,7 +6329,7 @@ var findCommand = registerCommand({
   }
 });
 function okWithTips(data, tips) {
-  const result = ok27(data);
+  const result = ok28(data);
   if (tips.length > 0) result.tips = normalizeTips5(tips);
   return result;
 }
@@ -6356,8 +6428,8 @@ function describeSelector(strategy, value, name) {
 }
 
 // src/commands/visual-tag.ts
-import { z as z29 } from "zod";
-import { ok as ok28, fail as fail13 } from "@dyyz1993/xcli-core";
+import { z as z30 } from "zod";
+import { ok as ok29, fail as fail14 } from "@dyyz1993/xcli-core";
 var SAFE_SET = "ahjkmnprtw3479".split("");
 var TAG_SCRIPT = `
 (function() {
@@ -6448,49 +6520,49 @@ var visualTagCommand = registerCommand({
   name: "visual-tag",
   description: "\u5728\u9875\u9762\u4E0A\u7ED9\u53EF\u4EA4\u4E92\u5143\u7D20\u53E0\u52A0\u9632\u6DF7\u6DC6\u77ED ID \u6807\u7B7E\uFF08\u89C6\u89C9\u5B9A\u4F4D\u7528\uFF09",
   scope: "page",
-  parameters: z29.object({
-    action: z29.enum(["tag", "lookup", "clear", "list"]),
-    id: z29.string().optional().describe("lookup \u65F6\u6307\u5B9A\u8981\u67E5\u7684 ID")
+  parameters: z30.object({
+    action: z30.enum(["tag", "lookup", "clear", "list"]),
+    id: z30.string().optional().describe("lookup \u65F6\u6307\u5B9A\u8981\u67E5\u7684 ID")
   }),
-  result: z29.object({
-    action: z29.string(),
-    tagged: z29.number().optional(),
-    id: z29.string().optional(),
-    element: z29.record(z29.unknown()).optional()
+  result: z30.object({
+    action: z30.string(),
+    tagged: z30.number().optional(),
+    id: z30.string().optional(),
+    element: z30.record(z30.unknown()).optional()
   }),
   handler: async (p, ctx) => {
     switch (p.action) {
       case "tag": {
         const result = await ctx.page.evaluate(TAG_SCRIPT);
         const parsed = JSON.parse(result);
-        return ok28({ action: "tag", tagged: parsed.tagged });
+        return ok29({ action: "tag", tagged: parsed.tagged });
       }
       case "lookup": {
-        if (!p.id) return fail13("lookup \u9700\u8981 --id \u53C2\u6570");
+        if (!p.id) return fail14("lookup \u9700\u8981 --id \u53C2\u6570");
         const result = await ctx.page.evaluate(
           `(function() { var m = window.__xbTagMap; if (!m) return JSON.stringify({err:'no-map'}); var e = m[${JSON.stringify(p.id)}]; return e ? JSON.stringify(e) : JSON.stringify({err:'not-found'}); })()`
         );
         const parsed = JSON.parse(result);
-        if (parsed.err) return fail13(`ID ${p.id}: ${parsed.err}`);
-        return ok28({ action: "lookup", id: p.id, element: parsed });
+        if (parsed.err) return fail14(`ID ${p.id}: ${parsed.err}`);
+        return ok29({ action: "lookup", id: p.id, element: parsed });
       }
       case "list": {
         const result = await ctx.page.evaluate(
           `(function() { var m = window.__xbTagMap; if (!m) return '{}'; var out = {}; for (var k in m) { out[k] = m[k].text || m[k].tagName; } return JSON.stringify(out); })()`
         );
-        return ok28({ action: "list", element: JSON.parse(result) });
+        return ok29({ action: "list", element: JSON.parse(result) });
       }
       case "clear": {
         await ctx.page.evaluate(`(function(){var o=document.getElementById('__xb-tag-overlay');if(o)o.remove();window.__xbTagMap=null;return 'cleared'})()`);
-        return ok28({ action: "clear" });
+        return ok29({ action: "clear" });
       }
     }
   }
 });
 
 // src/commands/visual-tag-v2.ts
-import { z as z30 } from "zod";
-import { ok as ok29, fail as fail14 } from "@dyyz1993/xcli-core";
+import { z as z31 } from "zod";
+import { ok as ok30, fail as fail15 } from "@dyyz1993/xcli-core";
 var SAFE_SET2 = "ahjkmnprtw3479".split("");
 var TAG_V2_SCRIPT = `
 (function() {
@@ -6837,45 +6909,45 @@ var visualTagV2Command = registerCommand({
   name: "visual-tag-v2",
   description: "\u5206\u8272\u6807\u6CE8\u9875\u9762\u5143\u7D20\uFF08\u7EA2=\u53EF\u70B9\u51FB \u84DD=\u8F93\u5165 \u7EFF=\u56FE\u7247 \u9EC4=\u5217\u8868 \u7D2B=\u6570\u5B57 \u6A59=\u6587\u672C\uFF09",
   scope: "page",
-  parameters: z30.object({
-    action: z30.enum(["tag", "lookup", "clear", "stats", "by-type", "find", "export", "interact"]),
-    id: z30.string().optional().describe("lookup \u65F6\u6307\u5B9A\u8981\u67E5\u7684 ID"),
-    query: z30.string().optional().describe('find \u65F6\u6307\u5B9A\u641C\u7D22\u8BCD\uFF08\u5982 "\u627E\u6709AI\u7F16\u7A0B\u6807\u7B7E\u7684\u5361\u7247"\uFF09'),
-    type: z30.string().optional().describe("by-type \u65F6\u8FC7\u6EE4\u7C7B\u578B\uFF1Aclick/input/img/list/count/text"),
-    "interact-action": z30.enum(["click", "fill", "read"]).optional().describe("interact \u52A8\u4F5C\u7C7B\u578B"),
-    value: z30.string().optional().describe("fill \u65F6\u7684\u586B\u5145\u503C")
+  parameters: z31.object({
+    action: z31.enum(["tag", "lookup", "clear", "stats", "by-type", "find", "export", "interact"]),
+    id: z31.string().optional().describe("lookup \u65F6\u6307\u5B9A\u8981\u67E5\u7684 ID"),
+    query: z31.string().optional().describe('find \u65F6\u6307\u5B9A\u641C\u7D22\u8BCD\uFF08\u5982 "\u627E\u6709AI\u7F16\u7A0B\u6807\u7B7E\u7684\u5361\u7247"\uFF09'),
+    type: z31.string().optional().describe("by-type \u65F6\u8FC7\u6EE4\u7C7B\u578B\uFF1Aclick/input/img/list/count/text"),
+    "interact-action": z31.enum(["click", "fill", "read"]).optional().describe("interact \u52A8\u4F5C\u7C7B\u578B"),
+    value: z31.string().optional().describe("fill \u65F6\u7684\u586B\u5145\u503C")
   }),
-  result: z30.object({
-    action: z30.string(),
-    total: z30.number().optional(),
-    byType: z30.record(z30.number()).optional(),
-    element: z30.record(z30.unknown()).optional()
+  result: z31.object({
+    action: z31.string(),
+    total: z31.number().optional(),
+    byType: z31.record(z31.number()).optional(),
+    element: z31.record(z31.unknown()).optional()
   }),
   handler: async (p, ctx) => {
     switch (p.action) {
       case "tag": {
         const result = await ctx.page.evaluate(TAG_V2_SCRIPT);
         const parsed = JSON.parse(result);
-        return ok29({ action: "tag", total: parsed.total, byType: parsed.byType });
+        return ok30({ action: "tag", total: parsed.total, byType: parsed.byType });
       }
       case "lookup": {
-        if (!p.id) return fail14("lookup \u9700\u8981 --id");
+        if (!p.id) return fail15("lookup \u9700\u8981 --id");
         const result = await ctx.page.evaluate(
           `(function(){var m=window.__xbTagMap;if(!m)return JSON.stringify({err:'no-map'});var e=m[${JSON.stringify(p.id)}];return e?JSON.stringify(e):JSON.stringify({err:'not-found'})})()`
         );
         const parsed = JSON.parse(result);
-        if (parsed.err) return fail14(`ID ${p.id}: ${parsed.err}`);
-        return ok29({ action: "lookup", id: p.id, element: parsed });
+        if (parsed.err) return fail15(`ID ${p.id}: ${parsed.err}`);
+        return ok30({ action: "lookup", id: p.id, element: parsed });
       }
       case "by-type": {
         const result = await ctx.page.evaluate(
           `(function(){var m=window.__xbTagMap;if(!m)return'{}';var out={};for(var k in m){if(!${JSON.stringify(p.type || "")}||m[k].type===${JSON.stringify(p.type || "")}){out[k]={type:m[k].type,text:m[k].text,num:m[k].num,label:m[k].formLabel}}}return JSON.stringify(out)})()`
         );
-        return ok29({ action: "by-type", element: JSON.parse(result) });
+        return ok30({ action: "by-type", element: JSON.parse(result) });
       }
       case "find": {
         const query = p.query;
-        if (!query) return fail14('find \u9700\u8981 --query \u53C2\u6570\uFF08\u5982 "\u627E\u6709AI\u7F16\u7A0B\u6807\u7B7E\u7684\u5361\u7247"\uFF09');
+        if (!query) return fail15('find \u9700\u8981 --query \u53C2\u6570\uFF08\u5982 "\u627E\u6709AI\u7F16\u7A0B\u6807\u7B7E\u7684\u5361\u7247"\uFF09');
         const result = await ctx.page.evaluate(
           `(function(){
             var map = window.__xbTagSerializable;
@@ -6917,21 +6989,21 @@ var visualTagV2Command = registerCommand({
             return JSON.stringify({total:results.length, results:results.slice(0,20)});
           })()`
         );
-        return ok29({ action: "find", query, element: JSON.parse(result) });
+        return ok30({ action: "find", query, element: JSON.parse(result) });
       }
       case "stats": {
         const result = await ctx.page.evaluate(
           `(function(){return JSON.stringify(window.__xbTagStats||{})})()`
         );
-        return ok29({ action: "stats", element: JSON.parse(result) });
+        return ok30({ action: "stats", element: JSON.parse(result) });
       }
       case "interact": {
         const query = p.query;
         const pAny = p;
         const action = pAny["interact-action"] || pAny.interactAction || pAny.interact_action;
         const value = pAny.value;
-        if (!query) return fail14("interact \u9700\u8981 --query \u53C2\u6570");
-        if (!action) return fail14("interact \u9700\u8981 --interact-action \u53C2\u6570\uFF08click/fill/read\uFF09");
+        if (!query) return fail15("interact \u9700\u8981 --query \u53C2\u6570");
+        if (!action) return fail15("interact \u9700\u8981 --interact-action \u53C2\u6570\uFF08click/fill/read\uFF09");
         const findResult = await ctx.page.evaluate(
           `(function(){
             var map = window.__xbTagSerializable;
@@ -6961,11 +7033,11 @@ var visualTagV2Command = registerCommand({
           })()`
         );
         const parsed = JSON.parse(findResult);
-        if (parsed.err) return fail14(parsed.err);
-        if (!parsed.total || !parsed.results?.length) return fail14(`\u672A\u627E\u5230\u5339\u914D "${query}" \u7684\u5143\u7D20`);
+        if (parsed.err) return fail15(parsed.err);
+        if (!parsed.total || !parsed.results?.length) return fail15(`\u672A\u627E\u5230\u5339\u914D "${query}" \u7684\u5143\u7D20`);
         const target = parsed.results[0];
         if (action === "read") {
-          return ok29({ action: "interact", query, target, result: { read: target.text || target.label } });
+          return ok30({ action: "interact", query, target, result: { read: target.text || target.label } });
         }
         if (action === "click") {
           const el = await ctx.page.evaluate(
@@ -6978,12 +7050,12 @@ var visualTagV2Command = registerCommand({
               return {x: Math.round(r.x + r.width/2), y: Math.round(r.y + r.height/2)};
             })()`
           );
-          if (!el) return fail14(`\u5143\u7D20 ${target.id} \u4E0D\u53EF\u4EA4\u4E92`);
+          if (!el) return fail15(`\u5143\u7D20 ${target.id} \u4E0D\u53EF\u4EA4\u4E92`);
           await ctx.page.mouse.click(el.x, el.y, { stealth: true });
-          return ok29({ action: "interact", query, target, result: { clicked: true, x: el.x, y: el.y } });
+          return ok30({ action: "interact", query, target, result: { clicked: true, x: el.x, y: el.y } });
         }
         if (action === "fill") {
-          if (!value) return fail14("fill \u9700\u8981 --value \u53C2\u6570");
+          if (!value) return fail15("fill \u9700\u8981 --value \u53C2\u6570");
           const el = await ctx.page.evaluate(
             `(function(){
               var map = window.__xbTagMap;
@@ -6994,12 +7066,12 @@ var visualTagV2Command = registerCommand({
               return {x: Math.round(r.x + r.width/2), y: Math.round(r.y + r.height/2)};
             })()`
           );
-          if (!el) return fail14(`\u5143\u7D20 ${target.id} \u4E0D\u53EF\u4EA4\u4E92`);
+          if (!el) return fail15(`\u5143\u7D20 ${target.id} \u4E0D\u53EF\u4EA4\u4E92`);
           await ctx.page.mouse.click(el.x, el.y, { stealth: true });
           await ctx.page.keyboard.type(value, { stealth: true });
-          return ok29({ action: "interact", query, target, result: { filled: true, value } });
+          return ok30({ action: "interact", query, target, result: { filled: true, value } });
         }
-        return fail14(`\u672A\u77E5 action: ${action}`);
+        return fail15(`\u672A\u77E5 action: ${action}`);
       }
       case "export": {
         const result = await ctx.page.evaluate(
@@ -7047,12 +7119,12 @@ var visualTagV2Command = registerCommand({
           })()`
         );
         const parsed = JSON.parse(result);
-        if (parsed.err) return fail14(String(parsed.err));
-        return ok29({ action: "export", element: parsed });
+        if (parsed.err) return fail15(String(parsed.err));
+        return ok30({ action: "export", element: parsed });
       }
       case "clear": {
         await ctx.page.evaluate(`(function(){var o=document.getElementById('__xb-tag-overlay');if(o)o.remove();window.__xbTagMap=null;window.__xbTagStats=null;return 'ok'})()`);
-        return ok29({ action: "clear" });
+        return ok30({ action: "clear" });
       }
     }
   }
@@ -7722,7 +7794,7 @@ async function guardCheck(commandName) {
   }
 }
 function errorResult(message) {
-  return { ...fail15(message), duration: 0 };
+  return { ...fail16(message), duration: 0 };
 }
 function tipsToMessages(tips) {
   if (!tips || tips.length === 0) return [];
@@ -7995,7 +8067,7 @@ async function executeCommand(commandName, params, sessionName = "default", extr
         timestamp: start
       });
       if (isSuccess) {
-        return { ...ok30(raw.data, merged.length > 0 ? merged : raw.tips), duration, ...hookOutputs ? { hookOutputs } : {} };
+        return { ...ok31(raw.data, merged.length > 0 ? merged : raw.tips), duration, ...hookOutputs ? { hookOutputs } : {} };
       }
       const fc = classifyFailure(raw.message);
       return {
@@ -8018,7 +8090,7 @@ async function executeCommand(commandName, params, sessionName = "default", extr
       duration,
       timestamp: start
     });
-    return { ...ok30(raw, smartTipNormalized), duration, ...hookOutputs ? { hookOutputs } : {} };
+    return { ...ok31(raw, smartTipNormalized), duration, ...hookOutputs ? { hookOutputs } : {} };
   } catch (err) {
     const end = Date.now();
     const duration = end - start;
@@ -8063,7 +8135,7 @@ async function executeCommand(commandName, params, sessionName = "default", extr
       duration,
       timestamp: start
     });
-    return { ...fail15(errorMessage), duration };
+    return { ...fail16(errorMessage), duration };
   } finally {
   }
 }
@@ -8108,7 +8180,7 @@ async function executeChain(input, options) {
             results.push({
               command: cmdName,
               raw: cmdStr,
-              ...fail15(`Plugin "${cmdName}" requires a sub-command`),
+              ...fail16(`Plugin "${cmdName}" requires a sub-command`),
               duration: 0
             });
             if (type === "and") {
@@ -8127,7 +8199,7 @@ async function executeChain(input, options) {
             results.push({
               command: cmdName,
               raw: cmdStr,
-              ...fail15(`Unknown command "${subCommand}" for plugin "${cmdName}"`),
+              ...fail16(`Unknown command "${subCommand}" for plugin "${cmdName}"`),
               duration: 0
             });
             if (type === "and") {
@@ -8239,7 +8311,7 @@ async function executeChain(input, options) {
             results.push({
               command: `${cmdName} ${subCommand}`,
               raw: cmdStr,
-              ...ok30(data),
+              ...ok31(data),
               duration: duration2,
               ...hookOutputs ? { hookOutputs } : {}
             });
@@ -8267,7 +8339,7 @@ async function executeChain(input, options) {
             results.push({
               command: `${cmdName} ${subCommand}`,
               raw: cmdStr,
-              ...fail15(errorMessage),
+              ...fail16(errorMessage),
               duration: duration2
             });
             if (type === "and") {
@@ -9691,10 +9763,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 ok31 = input.ok ?? errors.length === 0;
+    const ok32 = input.ok ?? errors.length === 0;
     return {
-      ok: ok31,
-      success: ok31,
+      ok: ok32,
+      success: ok32,
       duration: typeof input.duration === "number" ? input.duration : 0,
       eventsPlayed,
       totalEvents,