@xbrowser/cli 0.16.0 → 1.0.2

package/dist/chunk-KFQGP6VL.js

@@ -0,0 +1,33 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+export {
+  __require,
+  __esm,
+  __export,
+  __toCommonJS
+};

package/dist/{chunk-ITKPSIP7.js → chunk-MDAPTB7C.js}

@@ -276,35 +276,17 @@ var WebhookNotifier = class {
 };
 
 // src/config.ts
-import { existsSync, mkdirSync, writeFileSync as writeFileSync2 } from "fs";
-import { join } from "path";
 import { homedir, tmpdir } from "os";
-
-// src/utils/json-file.ts
-import { readFileSync, writeFileSync } from "fs";
-function readJsonFile(filePath, defaultValue) {
-  try {
-    const content = readFileSync(filePath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return defaultValue;
-  }
-}
-
-// src/config.ts
-function getConfigFile() {
-  return join(homedir() || tmpdir(), ".xbrowser", "config.json");
+import { join } from "path";
+import { loadConfig as coreLoadConfig, saveConfig as coreSaveConfig } from "@dyyz1993/xcli-core";
+function getConfigSource() {
+  return { configDir: join(homedir() || tmpdir(), ".xbrowser") };
 }
 function loadConfig() {
-  const configFile = getConfigFile();
-  if (!existsSync(configFile)) return {};
-  return readJsonFile(configFile, {});
+  return coreLoadConfig(getConfigSource());
 }
 function saveConfig(config) {
-  const dir = join(homedir() || tmpdir(), ".xbrowser");
-  const configFile = getConfigFile();
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  writeFileSync2(configFile, JSON.stringify(config, null, 2), "utf-8");
+  coreSaveConfig(getConfigSource(), config);
 }
 function getConfigValue(key) {
   return loadConfig()[key];
@@ -510,7 +492,6 @@ var HumanInteractionManager = class {
 };
 
 export {
-  readJsonFile,
   ScreencastCapturer,
   CaptchaDetector,
   WebhookNotifier,

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
+};