@agenticmail/enterprise 0.5.78 → 0.5.80

package/dist/chunk-VX3VFMVB.js

@@ -0,0 +1,409 @@
+// src/browser/enterprise-compat.ts
+import crypto from "crypto";
+import fs from "fs";
+import fsp from "fs/promises";
+import path from "path";
+import os from "os";
+import net from "net";
+import { execFile } from "child_process";
+var _currentConfig = {};
+var _configDir = path.join(os.homedir(), ".agenticmail-enterprise");
+function loadConfig() {
+  return _currentConfig;
+}
+function createSubsystemLogger(name) {
+  const prefix = `[browser:${name}]`;
+  const logger = {
+    info: (...args) => console.log(prefix, ...args),
+    warn: (...args) => console.warn(prefix, ...args),
+    error: (...args) => console.error(prefix, ...args),
+    debug: (...args) => {
+    },
+    child: (sub) => createSubsystemLogger(`${name}:${sub}`)
+  };
+  return logger;
+}
+function formatErrorMessage(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  return String(err);
+}
+function isLoopbackHost(host) {
+  return /^(127\.\d+\.\d+\.\d+|::1|localhost)$/i.test(host);
+}
+function resolvePreferredOpenClawTmpDir() {
+  const dir = path.join(os.tmpdir(), "agenticmail-enterprise");
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+var DEFAULT_UPLOAD_DIR = path.join(os.tmpdir(), "agenticmail-uploads");
+function rawDataToString(data) {
+  if (typeof data === "string") return data;
+  if (Buffer.isBuffer(data)) return data.toString("utf-8");
+  if (data instanceof ArrayBuffer) return Buffer.from(data).toString("utf-8");
+  if (Array.isArray(data)) return Buffer.concat(data).toString("utf-8");
+  return String(data);
+}
+function formatCliCommand(cmd, args) {
+  return [cmd, ...args].join(" ");
+}
+function resolvePinnedHostnameWithPolicy(hostname, _policy) {
+  return hostname;
+}
+
+// src/browser/cdp.helpers.ts
+import WebSocket2 from "ws";
+
+// src/browser/extension-relay.ts
+import { createServer } from "http";
+import WebSocket, { WebSocketServer } from "ws";
+var RELAY_AUTH_HEADER = "x-openclaw-relay-token";
+function resolveGatewayAuthToken() {
+  const envToken = process.env.OPENCLAW_GATEWAY_TOKEN?.trim() || process.env.CLAWDBOT_GATEWAY_TOKEN?.trim();
+  if (envToken) {
+    return envToken;
+  }
+  try {
+    const cfg = loadConfig();
+    const configToken = cfg.gateway?.auth?.token?.trim();
+    if (configToken) {
+      return configToken;
+    }
+  } catch {
+  }
+  return null;
+}
+function relayAuthTokenForUrl(url) {
+  try {
+    const parsed = new URL(url);
+    if (!isLoopbackHost(parsed.hostname)) {
+      return null;
+    }
+    return resolveGatewayAuthToken();
+  } catch {
+    return null;
+  }
+}
+function getChromeExtensionRelayAuthHeaders(url) {
+  const token = relayAuthTokenForUrl(url);
+  if (!token) {
+    return {};
+  }
+  return { [RELAY_AUTH_HEADER]: token };
+}
+
+// src/browser/cdp.helpers.ts
+function getHeadersWithAuth(url, headers = {}) {
+  const relayHeaders = getChromeExtensionRelayAuthHeaders(url);
+  const mergedHeaders = { ...relayHeaders, ...headers };
+  try {
+    const parsed = new URL(url);
+    const hasAuthHeader = Object.keys(mergedHeaders).some(
+      (key) => key.toLowerCase() === "authorization"
+    );
+    if (hasAuthHeader) {
+      return mergedHeaders;
+    }
+    if (parsed.username || parsed.password) {
+      const auth = Buffer.from(`${parsed.username}:${parsed.password}`).toString("base64");
+      return { ...mergedHeaders, Authorization: `Basic ${auth}` };
+    }
+  } catch {
+  }
+  return mergedHeaders;
+}
+function appendCdpPath(cdpUrl, path5) {
+  const url = new URL(cdpUrl);
+  const basePath = url.pathname.replace(/\/$/, "");
+  const suffix = path5.startsWith("/") ? path5 : `/${path5}`;
+  url.pathname = `${basePath}${suffix}`;
+  return url.toString();
+}
+function createCdpSender(ws) {
+  let nextId = 1;
+  const pending = /* @__PURE__ */ new Map();
+  const send = (method, params, sessionId) => {
+    const id = nextId++;
+    const msg = { id, method, params, sessionId };
+    ws.send(JSON.stringify(msg));
+    return new Promise((resolve, reject) => {
+      pending.set(id, { resolve, reject });
+    });
+  };
+  const closeWithError = (err) => {
+    for (const [, p] of pending) {
+      p.reject(err);
+    }
+    pending.clear();
+    try {
+      ws.close();
+    } catch {
+    }
+  };
+  ws.on("error", (err) => {
+    closeWithError(err instanceof Error ? err : new Error(String(err)));
+  });
+  ws.on("message", (data) => {
+    try {
+      const parsed = JSON.parse(rawDataToString(data));
+      if (typeof parsed.id !== "number") {
+        return;
+      }
+      const p = pending.get(parsed.id);
+      if (!p) {
+        return;
+      }
+      pending.delete(parsed.id);
+      if (parsed.error?.message) {
+        p.reject(new Error(parsed.error.message));
+        return;
+      }
+      p.resolve(parsed.result);
+    } catch {
+    }
+  });
+  ws.on("close", () => {
+    closeWithError(new Error("CDP socket closed"));
+  });
+  return { send, closeWithError };
+}
+async function fetchJson(url, timeoutMs = 1500, init) {
+  const res = await fetchChecked(url, timeoutMs, init);
+  return await res.json();
+}
+async function fetchChecked(url, timeoutMs = 1500, init) {
+  const ctrl = new AbortController();
+  const t = setTimeout(ctrl.abort.bind(ctrl), timeoutMs);
+  try {
+    const headers = getHeadersWithAuth(url, init?.headers || {});
+    const res = await fetch(url, { ...init, headers, signal: ctrl.signal });
+    if (!res.ok) {
+      throw new Error(`HTTP ${res.status}`);
+    }
+    return res;
+  } finally {
+    clearTimeout(t);
+  }
+}
+async function withCdpSocket(wsUrl, fn, opts) {
+  const headers = getHeadersWithAuth(wsUrl, opts?.headers ?? {});
+  const handshakeTimeoutMs = typeof opts?.handshakeTimeoutMs === "number" && Number.isFinite(opts.handshakeTimeoutMs) ? Math.max(1, Math.floor(opts.handshakeTimeoutMs)) : 5e3;
+  const ws = new WebSocket2(wsUrl, {
+    handshakeTimeout: handshakeTimeoutMs,
+    ...Object.keys(headers).length ? { headers } : {}
+  });
+  const { send, closeWithError } = createCdpSender(ws);
+  const openPromise = new Promise((resolve, reject) => {
+    ws.once("open", () => resolve());
+    ws.once("error", (err) => reject(err));
+    ws.once("close", () => reject(new Error("CDP socket closed")));
+  });
+  try {
+    await openPromise;
+  } catch (err) {
+    closeWithError(err instanceof Error ? err : new Error(String(err)));
+    throw err;
+  }
+  try {
+    return await fn(send);
+  } catch (err) {
+    closeWithError(err instanceof Error ? err : new Error(String(err)));
+    throw err;
+  } finally {
+    try {
+      ws.close();
+    } catch {
+    }
+  }
+}
+
+// src/browser/navigation-guard.ts
+var NETWORK_NAVIGATION_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:"]);
+var InvalidBrowserNavigationUrlError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidBrowserNavigationUrlError";
+  }
+};
+function withBrowserNavigationPolicy(ssrfPolicy) {
+  return ssrfPolicy ? { ssrfPolicy } : {};
+}
+async function assertBrowserNavigationAllowed(opts) {
+  const rawUrl = String(opts.url ?? "").trim();
+  if (!rawUrl) {
+    throw new InvalidBrowserNavigationUrlError("url is required");
+  }
+  let parsed;
+  try {
+    parsed = new URL(rawUrl);
+  } catch {
+    throw new InvalidBrowserNavigationUrlError(`Invalid URL: ${rawUrl}`);
+  }
+  if (!NETWORK_NAVIGATION_PROTOCOLS.has(parsed.protocol)) {
+    return;
+  }
+  await resolvePinnedHostnameWithPolicy(parsed.hostname, {
+    lookupFn: opts.lookupFn,
+    policy: opts.ssrfPolicy
+  });
+}
+
+// src/browser/cdp.ts
+function normalizeCdpWsUrl(wsUrl, cdpUrl) {
+  const ws = new URL(wsUrl);
+  const cdp = new URL(cdpUrl);
+  if (isLoopbackHost(ws.hostname) && !isLoopbackHost(cdp.hostname)) {
+    ws.hostname = cdp.hostname;
+    const cdpPort = cdp.port || (cdp.protocol === "https:" ? "443" : "80");
+    if (cdpPort) {
+      ws.port = cdpPort;
+    }
+    ws.protocol = cdp.protocol === "https:" ? "wss:" : "ws:";
+  }
+  if (cdp.protocol === "https:" && ws.protocol === "ws:") {
+    ws.protocol = "wss:";
+  }
+  if (!ws.username && !ws.password && (cdp.username || cdp.password)) {
+    ws.username = cdp.username;
+    ws.password = cdp.password;
+  }
+  for (const [key, value] of cdp.searchParams.entries()) {
+    if (!ws.searchParams.has(key)) {
+      ws.searchParams.append(key, value);
+    }
+  }
+  return ws.toString();
+}
+function axValue(v) {
+  if (!v || typeof v !== "object") {
+    return "";
+  }
+  const value = v.value;
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  return "";
+}
+function formatAriaSnapshot(nodes, limit) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    if (n.nodeId) {
+      byId.set(n.nodeId, n);
+    }
+  }
+  const referenced = /* @__PURE__ */ new Set();
+  for (const n of nodes) {
+    for (const c of n.childIds ?? []) {
+      referenced.add(c);
+    }
+  }
+  const root = nodes.find((n) => n.nodeId && !referenced.has(n.nodeId)) ?? nodes[0];
+  if (!root?.nodeId) {
+    return [];
+  }
+  const out = [];
+  const stack = [{ id: root.nodeId, depth: 0 }];
+  while (stack.length && out.length < limit) {
+    const popped = stack.pop();
+    if (!popped) {
+      break;
+    }
+    const { id, depth } = popped;
+    const n = byId.get(id);
+    if (!n) {
+      continue;
+    }
+    const role = axValue(n.role);
+    const name = axValue(n.name);
+    const value = axValue(n.value);
+    const description = axValue(n.description);
+    const ref = `ax${out.length + 1}`;
+    out.push({
+      ref,
+      role: role || "unknown",
+      name: name || "",
+      ...value ? { value } : {},
+      ...description ? { description } : {},
+      ...typeof n.backendDOMNodeId === "number" ? { backendDOMNodeId: n.backendDOMNodeId } : {},
+      depth
+    });
+    const children = (n.childIds ?? []).filter((c) => byId.has(c));
+    for (let i = children.length - 1; i >= 0; i--) {
+      const child = children[i];
+      if (child) {
+        stack.push({ id: child, depth: depth + 1 });
+      }
+    }
+  }
+  return out;
+}
+
+// src/browser/chrome.ts
+import { spawn } from "child_process";
+import fs4 from "fs";
+import os3 from "os";
+import path4 from "path";
+import WebSocket3 from "ws";
+
+// src/browser/chrome.executables.ts
+import { execFileSync } from "child_process";
+import fs2 from "fs";
+import os2 from "os";
+import path2 from "path";
+
+// src/browser/chrome.profile-decoration.ts
+import fs3 from "fs";
+import path3 from "path";
+
+// src/browser/chrome.ts
+var log = createSubsystemLogger("browser").child("chrome");
+async function fetchChromeVersion(cdpUrl, timeoutMs = 500) {
+  const ctrl = new AbortController();
+  const t = setTimeout(ctrl.abort.bind(ctrl), timeoutMs);
+  try {
+    const versionUrl = appendCdpPath(cdpUrl, "/json/version");
+    const res = await fetch(versionUrl, {
+      signal: ctrl.signal,
+      headers: getHeadersWithAuth(versionUrl)
+    });
+    if (!res.ok) {
+      return null;
+    }
+    const data = await res.json();
+    if (!data || typeof data !== "object") {
+      return null;
+    }
+    return data;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(t);
+  }
+}
+async function getChromeWebSocketUrl(cdpUrl, timeoutMs = 500) {
+  const version = await fetchChromeVersion(cdpUrl, timeoutMs);
+  const wsUrl = String(version?.webSocketDebuggerUrl ?? "").trim();
+  if (!wsUrl) {
+    return null;
+  }
+  return normalizeCdpWsUrl(wsUrl, cdpUrl);
+}
+
+export {
+  createSubsystemLogger,
+  formatErrorMessage,
+  resolvePreferredOpenClawTmpDir,
+  formatCliCommand,
+  getHeadersWithAuth,
+  appendCdpPath,
+  fetchJson,
+  withCdpSocket,
+  withBrowserNavigationPolicy,
+  assertBrowserNavigationAllowed,
+  normalizeCdpWsUrl,
+  formatAriaSnapshot,
+  getChromeWebSocketUrl
+};