@xbrowser/cli 1.0.0 → 1.0.3

package/dist/chunk-OZKD3W4X.js

@@ -0,0 +1,417 @@
+import {
+  __esm,
+  __export,
+  __require
+} from "./chunk-KFQGP6VL.js";
+
+// src/recorder/site-knowledge.ts
+var site_knowledge_exports = {};
+__export(site_knowledge_exports, {
+  addKnownIssue: () => addKnownIssue,
+  getKnowledgeDir: () => getKnowledgeDir,
+  getKnowledgePath: () => getKnowledgePath,
+  listSiteKnowledge: () => listSiteKnowledge,
+  readSiteKnowledge: () => readSiteKnowledge,
+  readSiteKnowledgeMarkdown: () => readSiteKnowledgeMarkdown,
+  toMarkdown: () => toMarkdown,
+  updateSiteKnowledge: () => updateSiteKnowledge
+});
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function getKnowledgeDir() {
+  return join(homedir(), ".xbrowser", "knowledge");
+}
+function getKnowledgePath(domain, ext) {
+  return join(getKnowledgeDir(), `${domain}.${ext}`);
+}
+function extractDomain(url) {
+  try {
+    const u = new URL(url);
+    return u.hostname.replace(/^www\./, "");
+  } catch {
+    return "unknown";
+  }
+}
+function normalizePath(url) {
+  try {
+    const u = new URL(url);
+    return u.pathname;
+  } catch {
+    return url;
+  }
+}
+function extractSelectors(actions, pageUrl) {
+  const seen = /* @__PURE__ */ new Map();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const action of actions) {
+    if (normalizePath(action.url) !== normalizePath(pageUrl)) continue;
+    const el = action.element;
+    if (!el || !el.selector) continue;
+    const key = el.selector;
+    const existing = seen.get(key);
+    if (existing) {
+      existing.timesSeen++;
+      existing.lastSeen = now;
+    } else {
+      const description = buildDescription(el, action);
+      seen.set(key, {
+        selector: key,
+        tag: el.tag || "unknown",
+        description,
+        actionType: action.type,
+        role: el.role,
+        text: el.text?.substring(0, 60),
+        confidence: el.confidence || "medium",
+        lastSeen: now,
+        timesSeen: 1,
+        status: "active"
+      });
+    }
+  }
+  return Array.from(seen.values()).sort((a, b) => b.timesSeen - a.timesSeen);
+}
+function buildDescription(el, action) {
+  const parts = [];
+  if (el.text) parts.push(`"${el.text}"`);
+  if (el.placeholder) parts.push(`placeholder="${el.placeholder}"`);
+  if (el.ariaLabel) parts.push(`aria-label="${el.ariaLabel}"`);
+  if (el.role) parts.push(`role=${el.role}`);
+  if (el.type) parts.push(`type=${el.type}`);
+  const actionDesc = {
+    click: "clicked",
+    input: `filled with "${action.value?.substring(0, 30)}"`,
+    change: "changed",
+    submit: "submitted form",
+    dblclick: "double-clicked",
+    contextmenu: "right-clicked",
+    hover: "hovered over",
+    focus: "focused"
+  };
+  const verb = actionDesc[action.type] || action.type;
+  const base = parts.length > 0 ? parts.join(", ") : el.tag || "element";
+  return `${base} \u2014 ${verb}`;
+}
+function extractForms(actions, pageUrl) {
+  const forms = /* @__PURE__ */ new Map();
+  for (const action of actions) {
+    if (normalizePath(action.url) !== normalizePath(pageUrl)) continue;
+    const el = action.element;
+    if (!el) continue;
+    if (el.tag === "input" || el.tag === "textarea" || el.tag === "select") {
+      const formKey = "main";
+      const form = forms.get(formKey) || {
+        name: "Main Form",
+        action: pageUrl,
+        fields: []
+      };
+      if (!form.fields.some((f) => f.selector === el.selector)) {
+        form.fields.push({
+          selector: el.selector || "",
+          tag: el.tag,
+          label: el.ariaLabel || el.placeholder || el.text || el.selector || "",
+          inputType: el.type || el.tag,
+          placeholder: el.placeholder
+        });
+      }
+      forms.set(formKey, form);
+    }
+    if (action.type === "submit" || action.type === "click" && el.tag === "button" && el.text) {
+      const form = forms.get("main");
+      if (form && !form.submitSelector) {
+        form.submitSelector = el.selector;
+      }
+    }
+  }
+  return Array.from(forms.values());
+}
+function extractNavLinks(actions) {
+  const links = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const action of actions) {
+    if (action.type !== "click" && action.type !== "navigation") continue;
+    const el = action.element;
+    if (!el || el.tag !== "a" || !el.text) continue;
+    const href = el.href || action.url;
+    if (!href || seen.has(href)) continue;
+    seen.add(href);
+    links.push({
+      text: el.text.substring(0, 40),
+      href,
+      selector: el.selector || ""
+    });
+  }
+  return links;
+}
+function extractApiEndpoints(network, existingEndpoints) {
+  const endpoints = {};
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (existingEndpoints) {
+    for (const [key, ep] of Object.entries(existingEndpoints)) {
+      endpoints[key] = ep;
+    }
+  }
+  for (const entry of network) {
+    if (!entry.url.includes("/api/") && !entry.url.includes("/v1/") && !entry.url.includes("/v2/") && entry.contentType && !entry.contentType.includes("json") && !entry.contentType.includes("text/")) continue;
+    if (["image", "stylesheet", "font", "manifest"].includes(entry.resourceType)) continue;
+    let path;
+    try {
+      path = new URL(entry.url).pathname;
+    } catch {
+      continue;
+    }
+    const method = entry.method;
+    const key = `${method} ${path}`;
+    if (endpoints[key]) {
+      endpoints[key].timesSeen++;
+      endpoints[key].lastSeen = now;
+    } else {
+      let params = [];
+      if (entry.requestBody && typeof entry.requestBody === "object") {
+        params = Object.keys(entry.requestBody).slice(0, 10);
+      }
+      let responseFields = [];
+      if (entry.responseBody && typeof entry.responseBody === "object") {
+        const resp = entry.responseBody;
+        responseFields = Object.keys(resp).slice(0, 10);
+        if (resp.data && typeof resp.data === "object") {
+          const dataKeys = Object.keys(resp.data).slice(0, 10);
+          responseFields = [...responseFields, ...dataKeys.map((k) => `data.${k}`)];
+        }
+      }
+      endpoints[key] = {
+        method,
+        url: entry.url.substring(0, 200),
+        path,
+        params,
+        responseFields,
+        lastSeen: now,
+        timesSeen: 1
+      };
+    }
+  }
+  return endpoints;
+}
+function mergePages(existing, newPages) {
+  const merged = { ...existing };
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const [path, newPage] of Object.entries(newPages)) {
+    if (merged[path]) {
+      const old = merged[path];
+      const selectorMap = /* @__PURE__ */ new Map();
+      for (const sel of old.selectors) selectorMap.set(sel.selector, sel);
+      for (const sel of newPage.selectors) {
+        const existing2 = selectorMap.get(sel.selector);
+        if (existing2) {
+          existing2.timesSeen += sel.timesSeen;
+          existing2.lastSeen = now;
+          existing2.status = "active";
+        } else {
+          selectorMap.set(sel.selector, sel);
+        }
+      }
+      const newSelectorSet = new Set(newPage.selectors.map((s) => s.selector));
+      for (const sel of selectorMap.values()) {
+        if (!newSelectorSet.has(sel.selector) && sel.timesSeen > 0) {
+        }
+      }
+      merged[path] = {
+        ...newPage,
+        selectors: Array.from(selectorMap.values()).sort((a, b) => b.timesSeen - a.timesSeen),
+        forms: newPage.forms.length > 0 ? newPage.forms : old.forms,
+        navigationLinks: [.../* @__PURE__ */ new Set([...old.navigationLinks, ...newPage.navigationLinks])].slice(0, 50),
+        lastVisited: now
+      };
+    } else {
+      merged[path] = newPage;
+    }
+  }
+  return merged;
+}
+function updateSiteKnowledge(data) {
+  const domain = extractDomain(data.startUrl);
+  const jsonPath = getKnowledgePath(domain, "json");
+  let existing = null;
+  if (existsSync(jsonPath)) {
+    try {
+      existing = JSON.parse(readFileSync(jsonPath, "utf-8"));
+    } catch {
+      existing = null;
+    }
+  }
+  const pageMap = /* @__PURE__ */ new Map();
+  for (const action of data.actions) {
+    const path = normalizePath(action.url);
+    if (!pageMap.has(path)) pageMap.set(path, []);
+    pageMap.get(path).push(action);
+  }
+  const newPages = {};
+  for (const [path, actions] of pageMap) {
+    const fullUrl = actions[0]?.url || data.startUrl;
+    newPages[path] = {
+      url: fullUrl,
+      title: actions[0]?.pageTitle || "",
+      selectors: extractSelectors(data.actions, fullUrl),
+      forms: extractForms(data.actions, fullUrl),
+      navigationLinks: extractNavLinks(actions),
+      lastVisited: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  const apiEndpoints = extractApiEndpoints(data.network, existing?.apiEndpoints);
+  const pages = existing ? mergePages(existing.pages, newPages) : newPages;
+  const knowledge = {
+    domain,
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+    recordingCount: (existing?.recordingCount || 0) + 1,
+    pages,
+    apiEndpoints,
+    knownIssues: existing?.knownIssues || [],
+    generatedBy: "xbrowser-recorder"
+  };
+  mkdirSync(getKnowledgeDir(), { recursive: true });
+  writeFileSync(jsonPath, JSON.stringify(knowledge, null, 2), "utf-8");
+  writeFileSync(getKnowledgePath(domain, "md"), toMarkdown(knowledge), "utf-8");
+  return knowledge;
+}
+function toMarkdown(kb) {
+  const lines = [];
+  lines.push(`# Site Knowledge: ${kb.domain}`);
+  lines.push("");
+  lines.push("> **Auto-generated by xbrowser recorder. This document is for LLM consumption.**");
+  lines.push("> Use these selectors when writing automation scripts for this site.");
+  lines.push(`> Updated: ${kb.lastUpdated} | Recordings: ${kb.recordingCount}`);
+  lines.push("");
+  lines.push("## Pages");
+  lines.push("");
+  for (const page of Object.values(kb.pages)) {
+    lines.push(`### ${page.url}`);
+    lines.push(`- **Path**: ${normalizePath(page.url)}`);
+    if (page.title) lines.push(`- **Title**: ${page.title}`);
+    lines.push(`- **Last Visited**: ${page.lastVisited}`);
+    lines.push("");
+    if (page.selectors.length > 0) {
+      lines.push("#### Selectors");
+      lines.push("");
+      lines.push("| Selector | Tag | Action | Description | Confidence | Seen |");
+      lines.push("|----------|-----|--------|-------------|------------|------|");
+      for (const sel of page.selectors) {
+        const status = sel.status === "deprecated" ? " \u26A0\uFE0FDEPRECATED" : "";
+        lines.push(
+          `| \`${sel.selector}\` | ${sel.tag} | ${sel.actionType} | ${sel.description} | ${sel.confidence} | ${sel.timesSeen}x${status} |`
+        );
+      }
+      lines.push("");
+    }
+    if (page.forms.length > 0) {
+      lines.push("#### Forms");
+      lines.push("");
+      for (const form of page.forms) {
+        lines.push(`- **${form.name}** (${form.action})`);
+        for (const field of form.fields) {
+          const parts = [field.tag, field.inputType];
+          if (field.placeholder) parts.push(`placeholder="${field.placeholder}"`);
+          lines.push(`  - \`${field.selector}\` \u2192 ${field.label} (${parts.join(", ")})`);
+        }
+        if (form.submitSelector) {
+          lines.push(`  - Submit: \`${form.submitSelector}\``);
+        }
+      }
+      lines.push("");
+    }
+    if (page.navigationLinks.length > 0) {
+      lines.push("#### Navigation Links");
+      lines.push("");
+      for (const link of page.navigationLinks.slice(0, 20)) {
+        lines.push(`- [${link.text}](${link.href}) \u2192 \`${link.selector}\``);
+      }
+      lines.push("");
+    }
+  }
+  const endpoints = Object.values(kb.apiEndpoints);
+  if (endpoints.length > 0) {
+    lines.push("## API Endpoints");
+    lines.push("");
+    lines.push("| Method | Path | Params | Response Fields | Frequency |");
+    lines.push("|--------|------|--------|-----------------|-----------|");
+    for (const ep of endpoints.sort((a, b) => b.timesSeen - a.timesSeen)) {
+      const params = ep.params.length > 0 ? ep.params.join(", ") : "-";
+      const respFields = ep.responseFields.length > 0 ? ep.responseFields.slice(0, 5).join(", ") : "-";
+      lines.push(`| ${ep.method} | ${ep.path} | ${params} | ${respFields} | ${ep.timesSeen}x |`);
+    }
+    lines.push("");
+  }
+  if (kb.knownIssues.length > 0) {
+    lines.push("## Known Issues");
+    lines.push("");
+    for (const issue of kb.knownIssues) {
+      lines.push(`- ${issue}`);
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("## How to Use This Document");
+  lines.push("");
+  lines.push("When writing automation scripts for this site:");
+  lines.push("1. Use the selectors from the **Selectors** tables above");
+  lines.push("2. Prefer selectors with **high confidence** and **higher Seen count**");
+  lines.push("3. For form filling, follow the **Forms** structure");
+  lines.push("4. For API interactions, reference the **API Endpoints** table");
+  lines.push("5. If a selector fails, it may be **deprecated** \u2014 check for alternative selectors");
+  lines.push("");
+  return lines.join("\n");
+}
+function readSiteKnowledge(domain) {
+  const path = getKnowledgePath(domain, "json");
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function readSiteKnowledgeMarkdown(domain) {
+  const path = getKnowledgePath(domain, "md");
+  if (!existsSync(path)) return null;
+  try {
+    return readFileSync(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function listSiteKnowledge() {
+  const dir = getKnowledgeDir();
+  if (!existsSync(dir)) return [];
+  try {
+    const files = __require("fs").readdirSync(dir);
+    return files.filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", ""));
+  } catch {
+    return [];
+  }
+}
+function addKnownIssue(domain, issue) {
+  const kb = readSiteKnowledge(domain);
+  if (!kb) return;
+  const dated = `[${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}] ${issue}`;
+  kb.knownIssues.push(dated);
+  kb.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+  writeFileSync(getKnowledgePath(domain, "json"), JSON.stringify(kb, null, 2), "utf-8");
+  writeFileSync(getKnowledgePath(domain, "md"), toMarkdown(kb), "utf-8");
+}
+var init_site_knowledge = __esm({
+  "src/recorder/site-knowledge.ts"() {
+  }
+});
+
+export {
+  getKnowledgeDir,
+  getKnowledgePath,
+  updateSiteKnowledge,
+  toMarkdown,
+  readSiteKnowledge,
+  readSiteKnowledgeMarkdown,
+  listSiteKnowledge,
+  addKnownIssue,
+  site_knowledge_exports,
+  init_site_knowledge
+};

package/dist/{chunk-T4J4C2NZ.js → chunk-TNEN6VQ2.js}

@@ -1,6 +1,9 @@
+import {
+  errMsg
+} from "./chunk-GDKLH7ZY.js";
 import {
   __require
-} from "./chunk-3RG5ZIWI.js";
+} from "./chunk-KFQGP6VL.js";
 
 // src/cdp-driver/launcher.ts
 import { spawn } from "child_process";
@@ -71,7 +74,16 @@ async function launchChrome(options = {}) {
   const chromePath = executablePath ?? findChrome();
   if (!chromePath) {
     throw new Error(
-      "Chrome/Chromium not found. Set executablePath or install Chrome to a default location."
+      [
+        "Chrome/Chromium not found.",
+        "",
+        "\u63A8\u8350\uFF1A\u7528 cdp-tunnel \u590D\u7528\u4F60\u5DF2\u6709\u7684 Chrome\uFF08\u542B\u767B\u5F55\u6001\u3001\u53CD\u722C\u53CB\u597D\uFF09",
+        "  npx cdp-tunnel setup          # \u96F6\u5B89\u88C5\u4E00\u952E\u542F\u52A8\u4EE3\u7406 + \u52A0\u8F7D Chrome \u6269\u5C55",
+        "  xbrowser goto https://example.com --cdp http://localhost:9221",
+        "",
+        "\u6216\u6307\u5B9A Chrome \u8DEF\u5F84\uFF1A",
+        '  xbrowser config set browser.executablePath "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"'
+      ].join("\n")
     );
   }
   const port = await findFreePort();
@@ -84,7 +96,8 @@ async function launchChrome(options = {}) {
     "--disable-background-timer-throttling",
     "--disable-backgrounding-occluded-windows",
     "--disable-renderer-backgrounding",
-    "--disable-features=Translate"
+    "--disable-features=Translate",
+    "--disable-popup-blocking"
   ];
   if (headless) {
     allArgs.push("--headless", "--hide-scrollbars", "--mute-audio");
@@ -136,7 +149,7 @@ async function launchChrome(options = {}) {
   } catch (err) {
     const stderr = stderrLines.slice(-20).join("\n");
     const exitInfo = child.exitCode !== null ? ` (exit code: ${child.exitCode})` : " (still running)";
-    throw new Error(`${err.message}${exitInfo}
+    throw new Error(`${errMsg(err)}${exitInfo}
 Chrome stderr:
 ${stderr || "(empty)"}`);
   }