@xbrowser/cli 0.14.0

package/dist/chunk-3RG5ZIWI.js

@@ -0,0 +1,10 @@
+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');
+});
+
+export {
+  __require
+};

package/dist/chunk-43VX3TYN.js

@@ -0,0 +1,83 @@
+import {
+  readJsonFile
+} from "./chunk-YEN2ODUI.js";
+
+// src/config.ts
+var DEFAULT_REGISTRY_URL = "https://xbrowser.dev";
+var NPM_REGISTRY_URL = "https://registry.npmjs.org";
+function getRegistryUrl(options = {}, fallbackRegistry) {
+  return options["registry"] || process.env.XBROWSER_REGISTRY || fallbackRegistry || DEFAULT_REGISTRY_URL;
+}
+
+// src/plugin/builtins/shared.ts
+import { existsSync, writeFileSync, mkdirSync } from "fs";
+import { resolve } from "path";
+import { homedir } from "os";
+function getAuthDir() {
+  return resolve(homedir(), ".xbrowser");
+}
+function getAuthFile() {
+  return resolve(getAuthDir(), "auth.json");
+}
+function loadAuth() {
+  const authFile = getAuthFile();
+  if (!existsSync(authFile)) return null;
+  return readJsonFile(authFile, null);
+}
+function saveAuth(config) {
+  const dir = getAuthDir();
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(getAuthFile(), JSON.stringify(config, null, 2), "utf-8");
+}
+
+// src/utils/proxy-fetch.ts
+var patched = false;
+async function ensureProxyFetch() {
+  if (patched) return;
+  patched = true;
+  if (process.env.https_proxy && !process.env.HTTPS_PROXY) {
+    process.env.HTTPS_PROXY = process.env.https_proxy;
+  }
+  if (process.env.http_proxy && !process.env.HTTP_PROXY) {
+    process.env.HTTP_PROXY = process.env.http_proxy;
+  }
+  if (process.env.all_proxy && !process.env.ALL_PROXY) {
+    process.env.ALL_PROXY = process.env.all_proxy;
+  }
+  const proxyUrl = process.env.https_proxy || process.env.HTTPS_PROXY || process.env.http_proxy || process.env.HTTP_PROXY || process.env.all_proxy || process.env.ALL_PROXY;
+  if (!proxyUrl) return;
+  try {
+    const undici = await import("undici");
+    const EnvHttpProxyAgent = undici.EnvHttpProxyAgent;
+    const uFetch = undici.fetch;
+    const UFormData = undici.FormData;
+    if (EnvHttpProxyAgent && uFetch && UFormData) {
+      const agent = new EnvHttpProxyAgent();
+      globalThis.fetch = ((input, init) => {
+        const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+        const body = init?.body;
+        if (body instanceof globalThis.FormData && !(body instanceof UFormData)) {
+          const ufd = new UFormData();
+          body.forEach((value, key) => {
+            if (value instanceof Blob) {
+              ufd.append(key, value, value.name || "file");
+            } else {
+              ufd.append(key, value);
+            }
+          });
+          return uFetch(url, { ...init, body: ufd, dispatcher: agent });
+        }
+        return uFetch(url, { ...init, dispatcher: agent });
+      });
+    }
+  } catch {
+  }
+}
+
+export {
+  NPM_REGISTRY_URL,
+  getRegistryUrl,
+  loadAuth,
+  saveAuth,
+  ensureProxyFetch
+};

package/dist/chunk-ATFTAKMN.js

@@ -0,0 +1,267 @@
+// src/daemon/daemon.ts
+import { spawn } from "child_process";
+import { join, dirname } from "path";
+import { homedir } from "os";
+import { fileURLToPath } from "url";
+import { stopDaemon as xcliStopDaemon, isDaemonRunning, getDaemonStatus, killAllDaemon } from "@dyyz1993/xcli-core";
+var CONFIG_DIR = join(homedir(), ".xbrowser");
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var WORKER_PATH = join(__dirname, "daemon-main.js");
+function getDaemonConfig() {
+  return {
+    configDir: CONFIG_DIR,
+    workerEntryPath: WORKER_PATH,
+    basePort: 9224
+  };
+}
+async function startDaemonProcess(port = 9224) {
+  const config = getDaemonConfig();
+  if (isDaemonRunning(config)) {
+    const status = getDaemonStatus(config);
+    if (status.port === port && status.pid) {
+      return { pid: status.pid, port: status.port, startedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    }
+    await xcliStopDaemon(config);
+  }
+  const child = spawn("node", [WORKER_PATH], {
+    detached: true,
+    stdio: "ignore",
+    env: {
+      ...process.env,
+      XBROWSER_DAEMON_PORT: String(port)
+    }
+  });
+  child.unref();
+  return new Promise((resolve, reject) => {
+    let resolved = false;
+    const timeout = setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        reject(new Error("Daemon start timeout after 15s"));
+      }
+    }, 15e3);
+    const checkInterval = setInterval(() => {
+      if (isDaemonRunning(config)) {
+        const s = getDaemonStatus(config);
+        if (s.port === port && s.pid) {
+          resolved = true;
+          clearTimeout(timeout);
+          clearInterval(checkInterval);
+          resolve({ pid: s.pid, port: s.port, startedAt: (/* @__PURE__ */ new Date()).toISOString() });
+        }
+      }
+    }, 200);
+    child.on("error", (err) => {
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timeout);
+        clearInterval(checkInterval);
+        reject(err);
+      }
+    });
+  });
+}
+async function stopDaemonProcess() {
+  await xcliStopDaemon(getDaemonConfig());
+}
+async function killAllDaemonProcesses() {
+  await killAllDaemon(getDaemonConfig());
+}
+function getDaemonProcessStatus() {
+  const config = getDaemonConfig();
+  const running = isDaemonRunning(config);
+  if (!running) {
+    return { running: false, pid: 0, port: 0, info: null };
+  }
+  const status = getDaemonStatus(config);
+  return {
+    running: true,
+    pid: status.pid,
+    port: status.port,
+    info: { pid: status.pid, port: status.port, startedAt: (/* @__PURE__ */ new Date()).toISOString() }
+  };
+}
+
+// src/client/daemon-client.ts
+var DAEMON_PORT = 9224;
+var DAEMON_BASE = `http://localhost:${DAEMON_PORT}`;
+var _ensurePromise = null;
+async function ensureDaemonRunning() {
+  if (_ensurePromise) {
+    try {
+      await _ensurePromise;
+    } catch {
+    }
+    _ensurePromise = null;
+  }
+  for (let attempt = 0; attempt < 3; attempt++) {
+    const healthOk = await fetch(`${DAEMON_BASE}/health`, { signal: AbortSignal.timeout(2e3) }).then((r) => r.ok ? r.json() : null).then((d) => d?.status === "ok").catch(() => false);
+    if (healthOk) return;
+    if (attempt < 2) await new Promise((r) => setTimeout(r, 500));
+  }
+  _ensurePromise = startDaemonProcess(DAEMON_PORT).then(() => {
+  });
+  _ensurePromise.catch(() => {
+    _ensurePromise = null;
+  });
+  try {
+    await _ensurePromise;
+  } catch {
+    _ensurePromise = null;
+    throw new Error("Daemon not available");
+  }
+}
+async function rpcCall(method, params = {}, timeoutMs = 1e4) {
+  await ensureDaemonRunning();
+  const resp = await fetch(`${DAEMON_BASE}/rpc`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ method, params }),
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  if (!resp.ok) {
+    throw new Error(`Daemon error: ${resp.statusText}`);
+  }
+  return resp.json();
+}
+async function isDaemonRunning2() {
+  try {
+    const resp = await fetch(`${DAEMON_BASE}/health`, { signal: AbortSignal.timeout(2e3) });
+    if (!resp.ok) return false;
+    const data = await resp.json();
+    return data.status === "ok";
+  } catch {
+    return false;
+  }
+}
+async function daemonPing() {
+  try {
+    return await rpcCall("ping", {}, 2e3);
+  } catch {
+    return null;
+  }
+}
+async function forwardSessionCreate(name, url, cdpEndpoint) {
+  const params = { name, url };
+  if (cdpEndpoint) params.cdpEndpoint = cdpEndpoint;
+  return rpcCall("session:create", params, 3e4);
+}
+async function forwardSessionClose(name) {
+  return rpcCall("session:close", { name }, 1e4);
+}
+async function forwardSessionList() {
+  return rpcCall("session:list", {}, 5e3);
+}
+async function forwardExec(command, params, session = "default", cdpEndpoint, timeoutMs = 12e4) {
+  const rpcParams = { command, params, session };
+  if (cdpEndpoint) rpcParams.cdpEndpoint = cdpEndpoint;
+  try {
+    return await rpcCall("exec", rpcParams, timeoutMs);
+  } catch {
+    return { success: false, data: null, message: `Daemon error: exec failed`, duration: 0 };
+  }
+}
+async function forwardChain(input, session = "default", cdpEndpoint) {
+  const params = { chain: input, session };
+  if (cdpEndpoint) params.cdpEndpoint = cdpEndpoint;
+  try {
+    return await rpcCall("chain", params, 12e4);
+  } catch {
+    return { success: false, steps: [], totalDuration: 0, stoppedReason: "Daemon error" };
+  }
+}
+async function forwardNetworkList(sessionName, options) {
+  return rpcCall("network:list", { session: sessionName, ...options }, 3e4);
+}
+async function forwardNetworkClear(sessionName) {
+  return rpcCall("network:clear", { session: sessionName }, 1e4);
+}
+async function forwardNetworkTop(sessionName, options) {
+  return rpcCall("network:top", { session: sessionName, ...options }, 3e4);
+}
+async function forwardCommandLog(sessionName, limit) {
+  return rpcCall("command:log", { session: sessionName, limit }, 1e4);
+}
+async function forwardNetworkAnalyze(sessionName) {
+  return rpcCall("network:analyze", { session: sessionName }, 3e4);
+}
+async function forwardNetworkAround(sessionName, commandId, windowMs) {
+  return rpcCall("network:around", { session: sessionName, commandId, window: windowMs }, 1e4);
+}
+async function forwardNetworkCurl(sessionName, id) {
+  return rpcCall("network:curl", { session: sessionName, id }, 1e4);
+}
+async function forwardNetworkReplay(sessionName, id) {
+  return rpcCall("network:replay", { session: sessionName, id }, 3e4);
+}
+async function forwardNetworkLike(sessionName, id) {
+  return rpcCall("network:like", { session: sessionName, id }, 5e3);
+}
+async function forwardNetworkDislike(sessionName, id) {
+  return rpcCall("network:dislike", { session: sessionName, id }, 5e3);
+}
+async function forwardNetworkExport(sessionName, id, lang) {
+  return rpcCall("network:export", { session: sessionName, id, lang }, 1e4);
+}
+async function forwardNetworkInspect(sessionName, id) {
+  return rpcCall("network:inspect", { session: sessionName, id }, 1e4);
+}
+async function forwardRecordStart(session, url) {
+  return rpcCall("record:start", { session, url }, 15e3);
+}
+async function forwardRecordStop(session) {
+  return rpcCall("record:stop", { session }, 1e4);
+}
+async function forwardRecordStatus(session) {
+  return rpcCall("record:status", { session }, 5e3);
+}
+async function forwardRecordSummary(session) {
+  return rpcCall("record:summary", { session }, 5e3);
+}
+async function forwardReplay(file, session, slowMo) {
+  return rpcCall("replay", { file, session, slowMo }, 12e4);
+}
+async function forwardRecordCheckpoint(session, type, hint, selector) {
+  return rpcCall("record:checkpoint", { session, type, hint, selector }, 1e4);
+}
+async function forwardReplayResume(session) {
+  return rpcCall("replay:resume", { session }, 1e4);
+}
+async function forwardViewerCheckSelector(name, selector) {
+  return rpcCall("viewer:check-selector", { name, selector }, 5e3);
+}
+
+export {
+  getDaemonConfig,
+  startDaemonProcess,
+  stopDaemonProcess,
+  killAllDaemonProcesses,
+  getDaemonProcessStatus,
+  isDaemonRunning2 as isDaemonRunning,
+  daemonPing,
+  forwardSessionCreate,
+  forwardSessionClose,
+  forwardSessionList,
+  forwardExec,
+  forwardChain,
+  forwardNetworkList,
+  forwardNetworkClear,
+  forwardNetworkTop,
+  forwardCommandLog,
+  forwardNetworkAnalyze,
+  forwardNetworkAround,
+  forwardNetworkCurl,
+  forwardNetworkReplay,
+  forwardNetworkLike,
+  forwardNetworkDislike,
+  forwardNetworkExport,
+  forwardNetworkInspect,
+  forwardRecordStart,
+  forwardRecordStop,
+  forwardRecordStatus,
+  forwardRecordSummary,
+  forwardReplay,
+  forwardRecordCheckpoint,
+  forwardReplayResume,
+  forwardViewerCheckSelector
+};

package/dist/chunk-DESA2KMG.js

@@ -0,0 +1,77 @@
+import {
+  readJsonFile
+} from "./chunk-YEN2ODUI.js";
+
+// src/plugin/metadata-parser.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+var PluginMetadataParser = class {
+  static XBROWSER_KEYWORDS = ["xbrowser", "xbrowser-plugin"];
+  static parseFromPackageJson(pluginPath) {
+    const packageJsonPath = resolve(pluginPath, "package.json");
+    if (!existsSync(packageJsonPath)) {
+      return null;
+    }
+    const packageJson = readJsonFile(packageJsonPath, null);
+    if (!packageJson) return null;
+    if (!packageJson.xbrowser) {
+      return null;
+    }
+    const xbrowser = packageJson.xbrowser;
+    const metadata = {
+      id: xbrowser.id || packageJson.name,
+      name: xbrowser.name || packageJson.name,
+      description: xbrowser.description || packageJson.description || "",
+      version: xbrowser.version || packageJson.version || "1.0.0",
+      author: xbrowser.author || this.extractAuthor(packageJson.author),
+      homepage: xbrowser.homepage || packageJson.homepage,
+      commands: xbrowser.commands,
+      sites: xbrowser.sites,
+      tags: xbrowser.tags,
+      screenshot: xbrowser.screenshot,
+      license: xbrowser.license || packageJson.license
+    };
+    return metadata;
+  }
+  static isXBrowserPlugin(packageJson) {
+    if (packageJson.xbrowser) {
+      return true;
+    }
+    const keywords = packageJson.keywords;
+    if (!keywords) return false;
+    return this.XBROWSER_KEYWORDS.some((kw) => keywords.includes(kw));
+  }
+  static fromNPMResult(result) {
+    const author = typeof result.author === "string" ? result.author : result.author?.name || "Unknown";
+    return {
+      id: result.name,
+      name: result.name.replace(/^xbrowser-plugin-/, "").replace(/^@[^/]+\//, ""),
+      description: result.description || "",
+      version: result.version,
+      author,
+      homepage: result.homepage || result.links?.homepage,
+      tags: result.keywords,
+      license: ""
+    };
+  }
+  static extractAuthor(author) {
+    if (typeof author === "string") return author;
+    if (typeof author === "object" && author !== null) {
+      const authorObj = author;
+      return authorObj.name || "Unknown";
+    }
+    return "Unknown";
+  }
+  static validateMetadata(metadata) {
+    const errors = [];
+    if (!metadata.id) errors.push("id is required");
+    if (!metadata.name) errors.push("name is required");
+    if (!metadata.description) errors.push("description is required");
+    if (!metadata.version) errors.push("version is required");
+    return errors;
+  }
+};
+
+export {
+  PluginMetadataParser
+};

package/dist/chunk-DTJRVA76.js

@@ -0,0 +1,206 @@
+// src/commands/convert.ts
+function escapeString(str) {
+  return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+function generateJSScript(recording) {
+  const events = aggregateEvents(recording.events || []);
+  let script = `#!/usr/bin/env node
+// Auto-generated replay script from xbrowser
+// Start URL: ${recording.startUrl}
+// Events: ${events.length}
+
+import { chromium } from 'playwright';
+
+const START_URL = '${escapeString(recording.startUrl)}';
+
+async function main() {
+  const browser = await chromium.launch({ headless: true });
+  const context = await browser.newContext();
+  const page = await context.newPage();
+
+  console.log('Navigating to', START_URL);
+  await page.goto(START_URL, { waitUntil: 'domcontentloaded' });
+  await page.waitForTimeout(1000);
+`;
+  for (const event of events) {
+    script += generateJSEvent(event);
+  }
+  script += `
+  console.log('Replay completed!');
+  await browser.close();
+}
+
+main().catch((e) => { console.error(e); process.exit(1); });
+`;
+  return script;
+}
+function generateJSEvent(event) {
+  switch (event.type) {
+    case "click":
+      return `
+  // Click: ${event.selector}
+  await page.click('${escapeString(event.selector || "body")}');
+  await page.waitForTimeout(100);
+`;
+    case "type":
+    case "input":
+      return `
+  // Input: ${event.selector}
+  await page.fill('${escapeString(event.selector || "input")}', '${escapeString(event.data?.value || "")}');
+  await page.waitForTimeout(100);
+`;
+    case "keydown":
+    case "keypress":
+      if (event.data?.key === "Enter") {
+        return `
+  // Press Enter
+  await page.keyboard.press('Enter');
+  await page.waitForTimeout(100);
+`;
+      }
+      return "";
+    case "scroll":
+      return `
+  // Scroll
+  await page.evaluate(() => window.scrollTo(${event.data?.x || 0}, ${event.data?.y || 0}));
+  await page.waitForTimeout(50);
+`;
+    case "navigate":
+    case "page_load":
+      return "";
+    default:
+      return "";
+  }
+}
+function generatePythonScript(recording) {
+  const events = recording.events || [];
+  let script = `#!/usr/bin/env python3
+# Auto-generated replay script from xbrowser
+# Start URL: ${recording.startUrl}
+
+import asyncio
+from playwright.async_api import async_playwright
+
+START_URL = "${recording.startUrl}"
+
+async def main():
+    async with async_playwright() as p:
+        browser = await p.chromium.launch(headless=True)
+        context = await browser.new_context()
+        page = await context.new_page()
+
+        print(f"Navigating to {START_URL}")
+        await page.goto(START_URL)
+        await asyncio.sleep(1)
+`;
+  for (const event of events) {
+    script += generatePythonEvent(event);
+  }
+  script += `
+        print("Replay completed!")
+        await browser.close()
+
+asyncio.run(main())
+`;
+  return script;
+}
+function generatePythonEvent(event) {
+  switch (event.type) {
+    case "click":
+      return `        # Click: ${event.selector}
+        await page.click('${escapeString(event.selector || "body")}')
+        await asyncio.sleep(0.1)
+`;
+    case "type":
+    case "input":
+      return `        # Input: ${event.selector}
+        await page.fill('${escapeString(event.selector || "input")}', '${escapeString(event.data?.value || "")}')
+        await asyncio.sleep(0.1)
+`;
+    case "keydown":
+    case "keypress":
+      if (event.data?.key === "Enter") {
+        return `        # Press Enter
+        await page.keyboard.press('Enter')
+        await asyncio.sleep(0.1)
+`;
+      }
+      return "";
+    default:
+      return "";
+  }
+}
+function generateBashScript(recording) {
+  const events = recording.events || [];
+  let script = `#!/bin/bash
+# Auto-generated replay script from xbrowser
+# Start URL: ${recording.startUrl}
+
+CDP_URL="\${CDP_URL:-http://localhost:9222}"
+
+echo "Navigating to ${recording.startUrl}..."
+curl -s "$CDP_URL/json/new?${encodeURIComponent(recording.startUrl)}" > /dev/null
+sleep 2
+`;
+  for (const event of events) {
+    script += generateBashEvent(event);
+  }
+  script += `
+echo "Replay completed!"
+`;
+  return script;
+}
+function generateBashEvent(event) {
+  switch (event.type) {
+    case "click":
+      return `# Click: ${event.selector}
+curl -s "$CDP_URL/json/execute" -d '{
+  "method": "Runtime.evaluate",
+  "params": { "expression": "document.querySelector('${escapeString(event.selector || "body")}').click()" }
+}' > /dev/null
+sleep 0.1
+`;
+    case "type":
+    case "input":
+      return `# Input: ${event.selector}
+curl -s "$CDP_URL/json/execute" -d '{
+  "method": "Runtime.evaluate",
+  "params": { "expression": "document.querySelector('${escapeString(event.selector || "input")}').value = '${escapeString(event.data?.value || "")}'" }
+}' > /dev/null
+sleep 0.1
+`;
+    default:
+      return "";
+  }
+}
+function aggregateEvents(events) {
+  const aggregated = [];
+  let lastInput = null;
+  for (const event of events) {
+    if (event.type === "input" || event.type === "type") {
+      lastInput = event;
+    } else if (event.type === "keydown" || event.type === "keypress") {
+      if (lastInput) {
+        aggregated.push(lastInput);
+        lastInput = null;
+      }
+      aggregated.push(event);
+    } else {
+      if (lastInput) {
+        aggregated.push(lastInput);
+        lastInput = null;
+      }
+      aggregated.push(event);
+    }
+  }
+  if (lastInput) {
+    aggregated.push(lastInput);
+  }
+  return aggregated;
+}
+
+export {
+  generateJSScript,
+  generatePythonScript,
+  generateBashScript
+};