@xbrowser/cli 1.0.0 → 1.0.3

package/dist/launcher-L2JNDB2H.js

@@ -0,0 +1,20 @@
+import {
+  ANTI_DETECT_ARGS,
+  DEFAULT_ARGS,
+  connectToCDP,
+  findChrome,
+  getCDPTargets,
+  killChrome,
+  launchChrome
+} from "./chunk-TNEN6VQ2.js";
+import "./chunk-GDKLH7ZY.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  ANTI_DETECT_ARGS,
+  DEFAULT_ARGS,
+  connectToCDP,
+  findChrome,
+  getCDPTargets,
+  killChrome,
+  launchChrome
+};

package/dist/{launcher-KA7J32K5.js → launcher-OZXJQPNG.js}

@@ -6,7 +6,7 @@ import {
   getCDPTargets,
   killChrome,
   launchChrome
-} from "./chunk-T4J4C2NZ.js";
+} from "./chunk-AMI64BSD.js";
 import "./chunk-3RG5ZIWI.js";
 export {
   ANTI_DETECT_ARGS,

package/dist/{network-store-66A2RATI.js → network-store-XGZ25FFC.js}

@@ -4,7 +4,7 @@ import {
   commandLogStore,
   networkStore
 } from "./chunk-VEDJ5XSQ.js";
-import "./chunk-3RG5ZIWI.js";
+import "./chunk-KFQGP6VL.js";
 export {
   CommandLogStore,
   NetworkCaptureStore,

package/dist/{network-store-BN6QEZ7R.js → network-store-YVDNUREI.js}

@@ -1,4 +1,4 @@
-import "./chunk-3RG5ZIWI.js";
+import "./chunk-KFQGP6VL.js";
 
 // src/daemon/network-scorer.ts
 var DEFAULT_WEIGHTS = {

package/dist/{parse-action-dsl-T3DYC33D.js → parse-action-dsl-UM333TL2.js}

@@ -1,4 +1,4 @@
-import "./chunk-3RG5ZIWI.js";
+import "./chunk-KFQGP6VL.js";
 
 // src/lib/parse-action-dsl.ts
 function parseActionDsl(dsl) {

package/dist/{proxy-WKGUCH2C.js → proxy-C6CK3UH5.js}

@@ -1,7 +1,7 @@
 import {
   CDPInterceptorProxy
-} from "./chunk-ZZ2TFWIV.js";
-import "./chunk-3RG5ZIWI.js";
+} from "./chunk-ABXMBNQ6.js";
+import "./chunk-KFQGP6VL.js";
 export {
   CDPInterceptorProxy
 };

package/dist/session-recorder-RTDGURIJ.js

@@ -0,0 +1,8 @@
+import {
+  SessionRecorder
+} from "./chunk-ACFE6PKF.js";
+import "./chunk-OZKD3W4X.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  SessionRecorder
+};

package/dist/session-recorder-YI7YYM36.js

@@ -0,0 +1,7 @@
+import {
+  SessionRecorder
+} from "./chunk-2SVQTI2O.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  SessionRecorder
+};

package/dist/session-replayer-MY27H4DX.js

@@ -0,0 +1,276 @@
+import "./chunk-KFQGP6VL.js";
+
+// src/recorder/session-replayer.ts
+var SessionReplayer = class {
+  opts;
+  recording = null;
+  page = null;
+  constructor(opts) {
+    this.opts = {
+      cdpUrl: opts.cdpUrl,
+      page: opts.page,
+      stepDelay: opts.stepDelay ?? 500,
+      stepTimeout: opts.stepTimeout ?? 1e4,
+      onStep: opts.onStep,
+      onError: opts.onError
+    };
+  }
+  /** Load a recording from a file path or parsed JSON */
+  async load(source) {
+    if (typeof source === "string") {
+      const fs = await import("fs");
+      const raw = fs.readFileSync(source, "utf8");
+      this.recording = JSON.parse(raw);
+    } else {
+      this.recording = source;
+    }
+  }
+  /** Run the full replay */
+  async run() {
+    if (!this.recording) throw new Error("No recording loaded. Call load() first.");
+    if (this.opts.page) {
+      this.page = this.opts.page;
+    } else if (this.opts.cdpUrl) {
+      const { launch } = await import("./cdp-driver-D6WMSMWX.js");
+      const { browser } = await launch({ cdpEndpoint: this.opts.cdpUrl });
+      let contexts = browser.contexts();
+      for (let i = 0; i < 10 && contexts.length === 0; i++) {
+        await new Promise((r) => setTimeout(r, 500));
+        contexts = browser.contexts();
+      }
+      const context = contexts[0];
+      if (!context) throw new Error("No browser context available");
+      const pages = context.pages();
+      this.page = pages[0];
+    }
+    if (!this.page) throw new Error("No page available. Provide cdpUrl or page.");
+    const actions = this.recording.actions;
+    let success = 0;
+    let failed = 0;
+    let skipped = 0;
+    for (let i = 0; i < actions.length; i++) {
+      const action = actions[i];
+      this.opts.onStep?.(action, i, actions.length);
+      try {
+        if (action.trajectory) {
+          await this.replayTrajectory(action.trajectory);
+        }
+        await this.replayAction(action);
+        success++;
+      } catch (e) {
+        const err = e instanceof Error ? e : new Error(String(e));
+        this.opts.onError?.(action, err);
+        if (action.type === "navigation") {
+          skipped++;
+        } else {
+          failed++;
+        }
+      }
+      if (i < actions.length - 1) {
+        await new Promise((r) => setTimeout(r, this.opts.stepDelay));
+      }
+    }
+    return { success, failed, skipped };
+  }
+  /** Replay a single action */
+  async replayAction(action) {
+    const page = this.page;
+    const timeout = this.opts.stepTimeout;
+    switch (action.type) {
+      case "navigation":
+        await page.goto(action.url, { waitUntil: "domcontentloaded", timeout });
+        break;
+      case "goto":
+        await page.goto(action.url, { waitUntil: "domcontentloaded", timeout });
+        break;
+      case "click":
+      case "cdp-click": {
+        const selector = this.resolveSelector(action);
+        await page.waitForSelector(selector, { state: "visible", timeout });
+        await page.click(selector, { timeout });
+        break;
+      }
+      case "input": {
+        const selector = this.resolveSelector(action);
+        await page.waitForSelector(selector, { state: "visible", timeout });
+        await page.fill(selector, action.value ?? "", { timeout });
+        break;
+      }
+      case "cdp-fill": {
+        const selector = this.resolveSelector(action);
+        await page.waitForSelector(selector, { state: "visible", timeout });
+        await page.fill(selector, action.value ?? "", { timeout });
+        break;
+      }
+      case "change": {
+        const selector = this.resolveSelector(action);
+        await page.waitForSelector(selector, { state: "visible", timeout });
+        if (action.value) {
+          await page.selectOption(selector, action.value);
+        }
+        break;
+      }
+      case "filechooser": {
+        const selector = this.resolveSelector(action);
+        await page.waitForSelector(selector, { state: "visible", timeout });
+        const files = this.resolveFiles(action);
+        if (files.length > 0) {
+          await page.setInputFiles(selector, files);
+        }
+        break;
+      }
+      case "keydown": {
+        const key = action.key ?? "";
+        if (key === "Enter" || key === "Tab" || key === "Escape") {
+          await page.keyboard.press(key);
+        } else if (key === "Backspace") {
+          await page.keyboard.press("Backspace");
+        } else if (key === "Delete") {
+          await page.keyboard.press("Delete");
+        } else if (key.startsWith("Arrow")) {
+          await page.keyboard.press(key);
+        } else if (key.includes("+")) {
+          await page.keyboard.press(key.replace("Meta", "Meta").replace("Ctrl", "Control"));
+        }
+        break;
+      }
+      case "dblclick": {
+        const selector = this.resolveSelector(action);
+        if (selector) {
+          await page.waitForSelector(selector, { state: "visible", timeout });
+          await page.dblclick(selector, { timeout });
+        } else if (action.x !== void 0 && action.y !== void 0) {
+          await page.mouse.dblclick(action.x, action.y);
+        }
+        break;
+      }
+      case "contextmenu": {
+        const selector = this.resolveSelector(action);
+        if (selector) {
+          await page.waitForSelector(selector, { state: "visible", timeout });
+          await page.click(selector, { button: "right", timeout });
+        } else if (action.x !== void 0 && action.y !== void 0) {
+          await page.mouse.click(action.x, action.y, { button: "right" });
+        }
+        break;
+      }
+      case "hover": {
+        const selector = this.resolveSelector(action);
+        if (selector) {
+          await page.waitForSelector(selector, { state: "visible", timeout });
+          await page.hover(selector);
+        }
+        break;
+      }
+      case "drag": {
+        if (action.drag) {
+          const { fromX, fromY, toX, toY } = action.drag;
+          await page.mouse.move(fromX, fromY);
+          await page.mouse.down();
+          const steps = 5;
+          for (let i = 1; i <= steps; i++) {
+            await page.mouse.move(
+              fromX + (toX - fromX) * i / steps,
+              fromY + (toY - fromY) * i / steps
+            );
+            await new Promise((r) => setTimeout(r, 30));
+          }
+          await page.mouse.up();
+        }
+        break;
+      }
+      case "resize": {
+        break;
+      }
+      case "clipboard": {
+        break;
+      }
+      case "touch": {
+        if (action.touch) {
+          const { touchType, touches } = action.touch;
+          if (touchType === "start" && touches.length > 0) {
+            await page.mouse.move(touches[0].x, touches[0].y);
+            await page.mouse.down();
+          } else if (touchType === "end" && touches.length > 0) {
+            await page.mouse.move(touches[0].x, touches[0].y);
+            await page.mouse.up();
+          }
+        }
+        break;
+      }
+      case "focus": {
+        const selector = this.resolveSelector(action);
+        if (selector && action.focus?.focusType === "focus") {
+          await page.waitForSelector(selector, { state: "visible", timeout });
+          await page.click(selector, { timeout });
+        }
+        break;
+      }
+      case "visibility": {
+        break;
+      }
+      case "submit": {
+        const selector = this.resolveSelector(action);
+        if (selector) {
+          await page.click(selector, { timeout });
+        }
+        break;
+      }
+      case "scroll": {
+        await page.evaluate(() => {
+          window.scrollBy(action.scrollX ?? 0, action.scrollY ?? 0);
+        });
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  /** Replay a mouse trajectory (smooth movement between actions) */
+  async replayTrajectory(trajectory) {
+    const page = this.page;
+    const { points } = trajectory;
+    if (!points || points.length < 2) return;
+    for (let i = 0; i < points.length; i++) {
+      const { x, y, dt } = points[i];
+      if (dt > 0) {
+        await new Promise((r) => setTimeout(r, Math.min(dt, 200)));
+      }
+      await page.mouse.move(x, y);
+    }
+  }
+  /** Resolve the best selector for an action */
+  resolveSelector(action) {
+    const el = action.element;
+    if (!el) return "";
+    if (el.textFallback) {
+    }
+    if (el.selector) {
+      return el.selector;
+    }
+    if (el.tag) {
+      return el.tag;
+    }
+    return "";
+  }
+  /** Resolve file payloads from a filechooser action */
+  resolveFiles(action) {
+    if (!action.files?.fileData) return [];
+    return action.files.fileData.filter((f) => f.dataUrl).map((f) => {
+      const match = f.dataUrl.match(/^data:[^;]+;base64,(.+)$/);
+      if (!match) return null;
+      return {
+        name: f.name,
+        mimeType: f.type || "application/octet-stream",
+        buffer: Buffer.from(match[1], "base64")
+      };
+    }).filter((f) => f !== null);
+  }
+  /** Clean up */
+  async close() {
+    this.page = null;
+  }
+};
+export {
+  SessionReplayer
+};

package/dist/site-knowledge-SYC6VCDB.js

@@ -0,0 +1,23 @@
+import {
+  addKnownIssue,
+  getKnowledgeDir,
+  getKnowledgePath,
+  init_site_knowledge,
+  listSiteKnowledge,
+  readSiteKnowledge,
+  readSiteKnowledgeMarkdown,
+  toMarkdown,
+  updateSiteKnowledge
+} from "./chunk-OZKD3W4X.js";
+import "./chunk-KFQGP6VL.js";
+init_site_knowledge();
+export {
+  addKnownIssue,
+  getKnowledgeDir,
+  getKnowledgePath,
+  listSiteKnowledge,
+  readSiteKnowledge,
+  readSiteKnowledgeMarkdown,
+  toMarkdown,
+  updateSiteKnowledge
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xbrowser/cli",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "description": "Browser automation CLI for web scraping, headless browsing, SEO analysis, and AI agent workflows. A command-line alternative to Playwright, Puppeteer, and Selenium.",
   "type": "module",
   "bin": {
@@ -74,16 +74,17 @@
     "dev": "tsup --watch",
     "lint": "eslint src/ bin/ --ext .ts",
     "lint:plugin-contract": "node lint-scripts/check-plugin-contract.mjs",
+    "lint:docs": "node lint-scripts/check-docs-consistency.mjs",
     "typecheck": "tsc --noEmit",
     "start": "node dist/cli.js",
     "test": "vitest run",
     "test:watch": "vitest",
-    "test:e2e": "vitest run tests/e2e/",
-    "validate": "npm run typecheck && npm run lint && npm run build && npm test",
+    "test:e2e": "vitest run --config vitest.e2e.config.ts",
+    "validate": "npm run typecheck && npm run lint && npm run lint:docs && npm run lint:plugin-contract && npm run build && npm test",
     "prepare": "husky"
   },
   "dependencies": {
-    "@dyyz1993/xcli-core": "^0.12.1",
+    "@dyyz1993/xcli-core": "^0.15.0",
     "@types/react-syntax-highlighter": "^15.5.13",
     "@types/turndown": "^5.0.6",
     "cheerio": "^1.2.0",

package/dist/screenshot-CWAWMXVA.js

@@ -1,28 +0,0 @@
-import "./chunk-3RG5ZIWI.js";
-
-// src/hooks/screenshot.ts
-var screenshotHook = {
-  name: "screenshot",
-  async onAfterCommand(ctx) {
-    try {
-      const quality = parseInt(process.env.XBROWSER_SCREENSHOT_QUALITY || "40");
-      const buffer = await ctx.page.screenshot({
-        type: "jpeg",
-        quality: Math.max(10, Math.min(100, quality))
-      });
-      const entry = {
-        step: ctx.command,
-        command: ctx.command,
-        base64: buffer.toString("base64"),
-        url: ctx.page.url(),
-        timestamp: Date.now()
-      };
-      return { screenshot: entry };
-    } catch {
-      return void 0;
-    }
-  }
-};
-export {
-  screenshotHook
-};

package/dist/session-recorder-MA75PKTQ.js

@@ -1,7 +0,0 @@
-import {
-  SessionRecorder
-} from "./chunk-2MFXKN32.js";
-import "./chunk-3RG5ZIWI.js";
-export {
-  SessionRecorder
-};