@diegosouzacdv/jev-browser-mcp 0.1.2 → 0.3.0

package/mcp_servers/jev-browser-npm/src/config.mjs

@@ -6,7 +6,7 @@ import { fileURLToPath } from "node:url";
 const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../..");
 const CONFIG_PATH = path.join(PACKAGE_ROOT, "config", "ui-testing.json");
 const CONFIG_KEYS = {
-  root: ["version", "browser", "jev"],
+  root: ["version", "browser", "jev", "jev_browser_mcp"],
   browser: [
     "mode",
     "harness_browser",
@@ -16,6 +16,30 @@ const CONFIG_KEYS = {
     "max_flow_steps",
     "max_text_entry_chars",
   ],
+  nodeBrowser: [
+    "max_action_timeout_seconds",
+    "max_upload_files",
+    "max_upload_path_chars",
+    "max_upload_file_bytes",
+    "max_upload_total_bytes",
+    "max_download_files",
+    "max_download_file_bytes",
+    "max_download_total_bytes",
+    "max_download_timeout_seconds",
+    "upload_root_env",
+    "artifact_directory",
+    "artifact_directory_env",
+    "max_frame_snapshots",
+    "fast_path_single_plan_default",
+    "screenshot_on_failure_default",
+    "trace_on_failure_default",
+    "capture_console_errors_default",
+    "capture_network_errors_default",
+    "block_trackers_default",
+    "snapshot_scope_default",
+    "tracker_host_suffixes",
+    "blocked_resource_types",
+  ],
   jev: [
     "provider_url",
     "credential_env",
@@ -27,6 +51,11 @@ const CONFIG_KEYS = {
     "max_action_description_chars",
     "max_response_bytes",
   ],
+  nodeJev: [
+    "max_diagnostic_items",
+    "max_diagnostic_chars",
+    "max_accessibility_violations",
+  ],
 };
 
 export class JevBrowserError extends Error {
@@ -57,6 +86,45 @@ function positiveNumber(value, name, integer = false) {
   return parsed;
 }
 
+function expandHomeDirectory(value) {
+  if (value.startsWith("~/") || value.startsWith("~\\")) return path.join(homedir(), value.slice(2));
+  return value;
+}
+
+function requireOutsidePackage(resolved, name) {
+  const insidePackage = path.relative(PACKAGE_ROOT, resolved);
+  if (insidePackage === "" || (!insidePackage.startsWith(`..${path.sep}`) && insidePackage !== ".." && !path.isAbsolute(insidePackage))) {
+    throw new JevBrowserError(`${name} must be outside the installed package directory`);
+  }
+  return resolved;
+}
+
+function configuredDirectory(value, name) {
+  if (typeof value !== "string" || !value.trim()) throw new JevBrowserError(`config/ui-testing.json ${name} must be a directory path`);
+  const expanded = expandHomeDirectory(value.trim());
+  if (!path.isAbsolute(expanded)) throw new JevBrowserError(`config/ui-testing.json ${name} must be absolute or start with ~`);
+  return path.resolve(expanded);
+}
+
+function environmentName(value, name) {
+  if (typeof value !== "string" || !/^[A-Z][A-Z0-9_]*$/.test(value)) {
+    throw new JevBrowserError(`config/ui-testing.json ${name} must be an environment variable name`);
+  }
+  return value;
+}
+
+function booleanValue(value, name) {
+  if (typeof value !== "boolean") throw new JevBrowserError(`config/ui-testing.json ${name} must be a boolean`);
+  return value;
+}
+
+function stringList(value, name, validator = () => true) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || !item.trim() || !validator(item))) {
+    throw new JevBrowserError(`config/ui-testing.json ${name} must be an array of valid strings`);
+  }
+  return value.map((item) => item.trim());
+}
+
 function validProviderUrl(value) {
   let parsed;
   try {
@@ -71,17 +139,9 @@ function validProviderUrl(value) {
 }
 
 function profileDirectory(template, channel, override) {
-  let value = override?.trim() || template.replace("{browser}", channel);
-  if (value.startsWith("~/") || value.startsWith("~\\")) {
-    value = path.join(homedir(), value.slice(2));
-  }
+  const value = expandHomeDirectory(override?.trim() || template.replace("{browser}", channel));
   if (!path.isAbsolute(value)) throw new JevBrowserError("JEV_BROWSER_PROFILE must be an absolute path");
-  const resolved = path.resolve(value);
-  const insidePackage = path.relative(PACKAGE_ROOT, resolved);
-  if (insidePackage === "" || (!insidePackage.startsWith(`..${path.sep}`) && insidePackage !== ".." && !path.isAbsolute(insidePackage))) {
-    throw new JevBrowserError("browser profile must be outside the installed package directory");
-  }
-  return resolved;
+  return requireOutsidePackage(path.resolve(value), "browser profile");
 }
 
 export function loadSettings({ env = process.env, configPath = CONFIG_PATH } = {}) {
@@ -94,6 +154,11 @@ export function loadSettings({ env = process.env, configPath = CONFIG_PATH } = {
   requireKeys(document, CONFIG_KEYS.root, "root");
   requireKeys(document.browser, CONFIG_KEYS.browser, "browser");
   requireKeys(document.jev, CONFIG_KEYS.jev, "jev");
+  requireKeys(document.jev_browser_mcp, ["browser", "jev"], "jev_browser_mcp");
+  requireKeys(document.jev_browser_mcp.browser, CONFIG_KEYS.nodeBrowser, "jev_browser_mcp.browser");
+  requireKeys(document.jev_browser_mcp.jev, CONFIG_KEYS.nodeJev, "jev_browser_mcp.jev");
+  const browserOptions = document.jev_browser_mcp.browser;
+  const jevOptions = document.jev_browser_mcp.jev;
   if (document.version !== 1) throw new JevBrowserError("config/ui-testing.json has an unsupported version");
 
   if (!new Set(["harness", "computer"]).has(document.browser.mode)) {
@@ -125,15 +190,37 @@ export function loadSettings({ env = process.env, configPath = CONFIG_PATH } = {
 
   const configuredProviderUrl = validProviderUrl(document.jev.provider_url);
   const providerUrl = validProviderUrl(env.JEV_PROVIDER_URL?.trim() || configuredProviderUrl);
-  const credentialEnv = String(document.jev.credential_env || "").trim();
-  if (!/^[A-Z][A-Z0-9_]*$/.test(credentialEnv)) {
-    throw new JevBrowserError("config/ui-testing.json jev.credential_env must be an environment variable name");
-  }
+  const credentialEnv = environmentName(document.jev.credential_env, "jev.credential_env");
   const configuredModel = String(document.jev.model || "").trim();
   if (!configuredModel) throw new JevBrowserError("config/ui-testing.json jev.model is required");
   const model = (env.JEV_MODEL?.trim() || configuredModel).trim();
   if (!model) throw new JevBrowserError("Jev model must not be empty");
 
+  const artifactEnv = environmentName(browserOptions.artifact_directory_env, "jev_browser_mcp.browser.artifact_directory_env");
+  const artifactDirectory = requireOutsidePackage(configuredDirectory(
+    env[artifactEnv]?.trim() || browserOptions.artifact_directory,
+    "jev_browser_mcp.browser.artifact_directory",
+  ), "browser artifact directory");
+  const uploadRootEnv = environmentName(browserOptions.upload_root_env, "jev_browser_mcp.browser.upload_root_env");
+  const configuredUploadRoot = env[uploadRootEnv]?.trim();
+  const uploadRoot = configuredUploadRoot
+    ? configuredDirectory(configuredUploadRoot, `environment ${uploadRootEnv}`)
+    : null;
+  const snapshotScope = browserOptions.snapshot_scope_default;
+  if (!new Set(["body", "main", "dialog"]).has(snapshotScope)) {
+    throw new JevBrowserError("config/ui-testing.json jev_browser_mcp.browser.snapshot_scope_default must be body, main, or dialog");
+  }
+  const trackerHostSuffixes = stringList(
+    browserOptions.tracker_host_suffixes,
+    "jev_browser_mcp.browser.tracker_host_suffixes",
+    (host) => /^[a-z0-9.-]+$/i.test(host) && !host.startsWith(".") && !host.endsWith("."),
+  );
+  const blockedResourceTypes = stringList(
+    browserOptions.blocked_resource_types,
+    "jev_browser_mcp.browser.blocked_resource_types",
+    (type) => new Set(["font", "media", "image"]).has(type),
+  );
+
   return Object.freeze({
     env,
     browser: Object.freeze({
@@ -142,6 +229,29 @@ export function loadSettings({ env = process.env, configPath = CONFIG_PATH } = {
       profileDir: profileDirectory(profileTemplate, channel, env.JEV_BROWSER_PROFILE),
       maxFlowSteps: positiveNumber(document.browser.max_flow_steps, "browser.max_flow_steps", true),
       maxTextEntryChars: positiveNumber(document.browser.max_text_entry_chars, "browser.max_text_entry_chars", true),
+      actionTimeoutMs: positiveNumber(browserOptions.max_action_timeout_seconds, "jev_browser_mcp.browser.max_action_timeout_seconds") * 1000,
+      maxUploadFiles: positiveNumber(browserOptions.max_upload_files, "jev_browser_mcp.browser.max_upload_files", true),
+      maxUploadPathChars: positiveNumber(browserOptions.max_upload_path_chars, "jev_browser_mcp.browser.max_upload_path_chars", true),
+      maxUploadFileBytes: positiveNumber(browserOptions.max_upload_file_bytes, "jev_browser_mcp.browser.max_upload_file_bytes", true),
+      maxUploadTotalBytes: positiveNumber(browserOptions.max_upload_total_bytes, "jev_browser_mcp.browser.max_upload_total_bytes", true),
+      maxDownloadFiles: positiveNumber(browserOptions.max_download_files, "jev_browser_mcp.browser.max_download_files", true),
+      maxDownloadFileBytes: positiveNumber(browserOptions.max_download_file_bytes, "jev_browser_mcp.browser.max_download_file_bytes", true),
+      maxDownloadTotalBytes: positiveNumber(browserOptions.max_download_total_bytes, "jev_browser_mcp.browser.max_download_total_bytes", true),
+      downloadTimeoutMs: positiveNumber(browserOptions.max_download_timeout_seconds, "jev_browser_mcp.browser.max_download_timeout_seconds") * 1000,
+      uploadRoot,
+      artifactDirectory,
+      maxFrameSnapshots: positiveNumber(browserOptions.max_frame_snapshots, "jev_browser_mcp.browser.max_frame_snapshots", true),
+      defaults: Object.freeze({
+        fastPath: booleanValue(browserOptions.fast_path_single_plan_default, "jev_browser_mcp.browser.fast_path_single_plan_default"),
+        screenshotOnFailure: booleanValue(browserOptions.screenshot_on_failure_default, "jev_browser_mcp.browser.screenshot_on_failure_default"),
+        traceOnFailure: booleanValue(browserOptions.trace_on_failure_default, "jev_browser_mcp.browser.trace_on_failure_default"),
+        captureConsoleErrors: booleanValue(browserOptions.capture_console_errors_default, "jev_browser_mcp.browser.capture_console_errors_default"),
+        captureNetworkErrors: booleanValue(browserOptions.capture_network_errors_default, "jev_browser_mcp.browser.capture_network_errors_default"),
+        blockTrackers: booleanValue(browserOptions.block_trackers_default, "jev_browser_mcp.browser.block_trackers_default"),
+        snapshotScope,
+      }),
+      trackerHostSuffixes: Object.freeze(trackerHostSuffixes),
+      blockedResourceTypes: Object.freeze(blockedResourceTypes),
     }),
     jev: Object.freeze({
       providerUrl,
@@ -153,6 +263,9 @@ export function loadSettings({ env = process.env, configPath = CONFIG_PATH } = {
       maxActionCount: positiveNumber(document.jev.max_action_count, "jev.max_action_count", true),
       maxActionDescriptionChars: positiveNumber(document.jev.max_action_description_chars, "jev.max_action_description_chars", true),
       maxResponseBytes: positiveNumber(document.jev.max_response_bytes, "jev.max_response_bytes", true),
+      maxDiagnosticItems: positiveNumber(jevOptions.max_diagnostic_items, "jev_browser_mcp.jev.max_diagnostic_items", true),
+      maxDiagnosticChars: positiveNumber(jevOptions.max_diagnostic_chars, "jev_browser_mcp.jev.max_diagnostic_chars", true),
+      maxAccessibilityViolations: positiveNumber(jevOptions.max_accessibility_violations, "jev_browser_mcp.jev.max_accessibility_violations", true),
     }),
   });
 }