@xbrowser/cli 0.14.0

package/dist/convert-4DUWZIKH.js

@@ -0,0 +1,205 @@
+// 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 {
+  generateBashScript,
+  generateJSScript,
+  generatePythonScript
+};

package/dist/convert-EKQVHKB4.js

@@ -0,0 +1,11 @@
+import {
+  generateBashScript,
+  generateJSScript,
+  generatePythonScript
+} from "./chunk-DTJRVA76.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  generateBashScript,
+  generateJSScript,
+  generatePythonScript
+};

package/dist/daemon-client-3IJD6X4B.js

@@ -0,0 +1,59 @@
+import {
+  daemonPing,
+  forwardChain,
+  forwardCommandLog,
+  forwardExec,
+  forwardNetworkAnalyze,
+  forwardNetworkAround,
+  forwardNetworkClear,
+  forwardNetworkCurl,
+  forwardNetworkDislike,
+  forwardNetworkExport,
+  forwardNetworkInspect,
+  forwardNetworkLike,
+  forwardNetworkList,
+  forwardNetworkReplay,
+  forwardNetworkTop,
+  forwardRecordCheckpoint,
+  forwardRecordStart,
+  forwardRecordStatus,
+  forwardRecordStop,
+  forwardRecordSummary,
+  forwardReplay,
+  forwardReplayResume,
+  forwardSessionClose,
+  forwardSessionCreate,
+  forwardSessionList,
+  forwardViewerCheckSelector,
+  isDaemonRunning
+} from "./chunk-ATFTAKMN.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  daemonPing,
+  forwardChain,
+  forwardCommandLog,
+  forwardExec,
+  forwardNetworkAnalyze,
+  forwardNetworkAround,
+  forwardNetworkClear,
+  forwardNetworkCurl,
+  forwardNetworkDislike,
+  forwardNetworkExport,
+  forwardNetworkInspect,
+  forwardNetworkLike,
+  forwardNetworkList,
+  forwardNetworkReplay,
+  forwardNetworkTop,
+  forwardRecordCheckpoint,
+  forwardRecordStart,
+  forwardRecordStatus,
+  forwardRecordStop,
+  forwardRecordSummary,
+  forwardReplay,
+  forwardReplayResume,
+  forwardSessionClose,
+  forwardSessionCreate,
+  forwardSessionList,
+  forwardViewerCheckSelector,
+  isDaemonRunning
+};

package/dist/daemon-client-GX2UYIW4.js

@@ -0,0 +1,241 @@
+// 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);
+      }
+    });
+  });
+}
+
+// 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 {
+  daemonPing,
+  forwardChain,
+  forwardCommandLog,
+  forwardExec,
+  forwardNetworkAnalyze,
+  forwardNetworkAround,
+  forwardNetworkClear,
+  forwardNetworkCurl,
+  forwardNetworkDislike,
+  forwardNetworkExport,
+  forwardNetworkInspect,
+  forwardNetworkLike,
+  forwardNetworkList,
+  forwardNetworkReplay,
+  forwardNetworkTop,
+  forwardRecordCheckpoint,
+  forwardRecordStart,
+  forwardRecordStatus,
+  forwardRecordStop,
+  forwardRecordSummary,
+  forwardReplay,
+  forwardReplayResume,
+  forwardSessionClose,
+  forwardSessionCreate,
+  forwardSessionList,
+  forwardViewerCheckSelector,
+  isDaemonRunning2 as isDaemonRunning
+};

package/dist/daemon-client-XWSSQBEA.js

@@ -0,0 +1,58 @@
+import {
+  daemonPing,
+  forwardChain,
+  forwardCommandLog,
+  forwardExec,
+  forwardNetworkAnalyze,
+  forwardNetworkAround,
+  forwardNetworkClear,
+  forwardNetworkCurl,
+  forwardNetworkDislike,
+  forwardNetworkExport,
+  forwardNetworkInspect,
+  forwardNetworkLike,
+  forwardNetworkList,
+  forwardNetworkReplay,
+  forwardNetworkTop,
+  forwardRecordCheckpoint,
+  forwardRecordStart,
+  forwardRecordStatus,
+  forwardRecordStop,
+  forwardRecordSummary,
+  forwardReplay,
+  forwardReplayResume,
+  forwardSessionClose,
+  forwardSessionCreate,
+  forwardSessionList,
+  forwardViewerCheckSelector,
+  isDaemonRunning
+} from "./chunk-ATFTAKMN.js";
+export {
+  daemonPing,
+  forwardChain,
+  forwardCommandLog,
+  forwardExec,
+  forwardNetworkAnalyze,
+  forwardNetworkAround,
+  forwardNetworkClear,
+  forwardNetworkCurl,
+  forwardNetworkDislike,
+  forwardNetworkExport,
+  forwardNetworkInspect,
+  forwardNetworkLike,
+  forwardNetworkList,
+  forwardNetworkReplay,
+  forwardNetworkTop,
+  forwardRecordCheckpoint,
+  forwardRecordStart,
+  forwardRecordStatus,
+  forwardRecordStop,
+  forwardRecordSummary,
+  forwardReplay,
+  forwardReplayResume,
+  forwardSessionClose,
+  forwardSessionCreate,
+  forwardSessionList,
+  forwardViewerCheckSelector,
+  isDaemonRunning
+};