@diegosouzacdv/jev-browser-mcp 0.4.2 → 0.6.0

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

@@ -1,4 +1,5 @@
 import { spawnSync } from "node:child_process";
+import { readlink } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { McpServer } from "@modelcontextprotocol/server";
@@ -18,12 +19,22 @@ class BrowserPool {
   #browser;
   #page;
   #startedAt;
+  #everStarted = false;
+  #navigationError;
   #flowQueue = Promise.resolve();
 
   constructor(settings) {
     this.#settings = settings;
   }
 
+  getNavigationError() {
+    return this.#navigationError;
+  }
+
+  setNavigationError(error) {
+    this.#navigationError = error || undefined;
+  }
+
   async runFlow(work) {
     const previous = this.#flowQueue;
     let release;
@@ -37,18 +48,60 @@ class BrowserPool {
   }
 
   async getPage() {
-    if (this.#page?.isClosed() && this.#context) {
-      this.#page = this.#context.pages()[0] || await this.#context.newPage();
-    }
-    const isOpening = !this.#contextPromise;
+    let isOpening = !this.#contextPromise;
     if (isOpening) {
+      this.#everStarted = true;
       this.#startedAt = performance.now();
       this.#contextPromise = this.#open();
     }
-    await this.#contextPromise;
+    try {
+      await this.#contextPromise;
+      if (this.#page?.isClosed() && this.#context) {
+        this.#page = this.#context.pages()[0] || await this.#context.newPage();
+      }
+    } catch (error) {
+      this.#invalidate("BROWSER_DISCONNECTED");
+      if (!isOpening) {
+        isOpening = true;
+        this.#startedAt = performance.now();
+        this.#contextPromise = this.#open();
+        await this.#contextPromise;
+      } else {
+        throw error;
+      }
+    }
     return { page: this.#page, context: this.#context, sessionMs: isOpening ? performance.now() - this.#startedAt : 0 };
   }
 
+  #invalidate(reason) {
+    this.#navigationError = reason;
+    this.#context = undefined;
+    this.#browser = undefined;
+    this.#page = undefined;
+    this.#contextPromise = undefined;
+  }
+
+  async health() {
+    if (!this.#everStarted) {
+      return { status: "not_started", connected: false };
+    }
+    try {
+      const { page, sessionMs } = await this.getPage();
+      return { status: "connected", connected: true, recovered: sessionMs > 0, current_url: page.url() };
+    } catch (error) {
+      return { status: "disconnected", connected: false, reason: error?.message || error?.name || "browser unavailable" };
+    }
+  }
+
+  #watchContext(context, browser) {
+    context.once("close", () => {
+      if (this.#context === context) this.#invalidate("BROWSER_DISCONNECTED");
+    });
+    browser?.once("disconnected", () => {
+      if (this.#browser === browser) this.#invalidate("BROWSER_DISCONNECTED");
+    });
+  }
+
   async #open() {
     const { mode, channel, profileDir } = this.#settings.browser;
     try {
@@ -57,37 +110,97 @@ class BrowserPool {
           channel,
           headless: false,
         });
+        this.#watchContext(this.#context);
         this.#page = this.#context.pages()[0] || await this.#context.newPage();
-      } else {
-        this.#browser = await chromium.launch({ channel, headless: true });
-        this.#context = await this.#browser.newContext();
-        this.#page = await this.#context.newPage();
+      } else {
+        this.#browser = await chromium.launch({ channel, headless: true });
+        this.#context = await this.#browser.newContext();
+        this.#watchContext(this.#context, this.#browser);
+        this.#page = await this.#context.newPage();
       }
+      this.#navigationError = undefined;
     } catch (error) {
-      this.#contextPromise = undefined;
+      this.#invalidate("BROWSER_DISCONNECTED");
+      const ownerPid = mode === "computer" ? await activeProfileOwnerPid(profileDir) : undefined;
+      if (ownerPid) {
+        throw new JevBrowserError(`browser profile is in use by PID ${ownerPid}; set JEV_BROWSER_PROFILE to a separate profile directory`);
+      }
       throw new JevBrowserError(
         `Could not start the configured ${channel} browser (${error?.name || "BrowserError"}); install it with jev-browser-mcp --install-browser`,
       );
     }
   }
 
-  async close() {
-    if (this.#context) await this.#context.close().catch(() => {});
-    if (this.#browser) await this.#browser.close().catch(() => {});
+  async close() {
+    if (this.#context) await this.#context.close().catch(() => {});
+    if (this.#browser) await this.#browser.close().catch(() => {});
     this.#context = undefined;
     this.#browser = undefined;
     this.#page = undefined;
     this.#contextPromise = undefined;
+    this.#navigationError = undefined;
   }
 }
 
-function toolError(error) {
-  const message = error instanceof JevBrowserError ? error.message : `Jev browser flow failed (${error?.name || "Error"})`;
-  return { isError: true, content: [{ type: "text", text: message }] };
+function toolError(error, settings) {
+  let message = error instanceof JevBrowserError ? error.message : error?.message || `Jev browser flow failed (${error?.name || "Error"})`;
+  const credential = settings.env?.[settings.jev.credentialEnv];
+  if (credential) message = message.split(credential).join("[redacted]");
+  message = message.replace(/\bBearer\s+\S+/gi, "Bearer [redacted]")
+    .replace(/([?&](?:token|api[_-]?key|password|secret)=)[^&\s]+/gi, "$1[redacted]");
+  return { isError: true, content: [{ type: "text", text: `[jev-browser ${packageManifest.version}] ${message}` }] };
 }
 
 function toolText(value) {
-  return { content: [{ type: "text", text: JSON.stringify(value) }] };
+  const versioned = value && typeof value === "object" && !Array.isArray(value)
+    ? { ...value, server_version: packageManifest.version }
+    : { result: value, server_version: packageManifest.version };
+  return { content: [{ type: "text", text: JSON.stringify(versioned) }] };
+}
+
+export function profileOwnerPidFromProcessList(processes, profileDir, platform = process.platform) {
+  const normalize = platform === "win32" ? path.win32.normalize : path.resolve;
+  const expectedProfile = normalize(profileDir).replace(/[\\/]+$/, "").toLowerCase();
+  for (const processInfo of Array.isArray(processes) ? processes : [processes]) {
+    if (!processInfo || typeof processInfo !== "object") continue;
+    const commandLine = typeof processInfo.CommandLine === "string" ? processInfo.CommandLine : "";
+    const match = commandLine.match(/(?:^|\s)--user-data-dir(?:=|\s+)(?:"([^"]+)"|'([^']+)'|([^\s"']+))/i);
+    const processProfile = match?.[1] || match?.[2] || match?.[3];
+    const pid = Number(processInfo.ProcessId ?? processInfo.pid);
+    if (!processProfile || !Number.isSafeInteger(pid) || pid <= 0) continue;
+    if (normalize(processProfile).replace(/[\\/]+$/, "").toLowerCase() === expectedProfile) return pid;
+  }
+  return undefined;
+}
+
+async function activeProfileOwnerPid(profileDir) {
+  try {
+    const lockTarget = await readlink(path.join(profileDir, "SingletonLock"));
+    const pid = Number(path.basename(lockTarget).match(/-(\d+)$/)?.[1]);
+    if (!Number.isSafeInteger(pid) || pid <= 0) return undefined;
+    try {
+      process.kill(pid, 0);
+      return pid;
+    } catch (error) {
+      if (error?.code === "EPERM") return pid;
+    }
+  } catch {
+    // Windows holds profile ownership in a process lock rather than a PID symlink.
+  }
+  if (process.platform !== "win32") return undefined;
+  const script = "$ErrorActionPreference='Stop'; Get-CimInstance Win32_Process -Filter \"Name='chrome.exe' OR Name='msedge.exe'\" | Select-Object ProcessId,CommandLine | ConvertTo-Json -Compress";
+  const listing = spawnSync("powershell.exe", ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", script], {
+    encoding: "utf8",
+    timeout: 2000,
+    windowsHide: true,
+  });
+  if (listing.status !== 0 || !listing.stdout?.trim()) return undefined;
+  try {
+    const processes = JSON.parse(listing.stdout);
+    return profileOwnerPidFromProcessList(processes, profileDir);
+  } catch {
+    return undefined;
+  }
 }
 
 export function createJevBrowserServer({ env = process.env, configPath, fetchImpl = fetch } = {}) {
@@ -109,6 +222,15 @@ export function createJevBrowserServer({ env = process.env, configPath, fetchImp
     }
   };
 
+  server.registerTool(
+    "browser_health",
+    {
+      description: "Check whether the managed browser session is connected. If a previously started browser exited, reconnects it and reports whether recovery succeeded.",
+      inputSchema: {},
+    },
+    async () => toolText(await browserPool.health()),
+  );
+
   server.registerTool(
     "choose_next_action",
     {
@@ -124,7 +246,7 @@ export function createJevBrowserServer({ env = process.env, configPath, fetchImp
       try {
         return toolText(await chooseNextAction({ flow, pageSnapshot, actions, completedSteps, settings, fetchImpl }));
       } catch (error) {
-        return toolError(error);
+        return toolError(error, settings);
       }
     },
   );
@@ -132,29 +254,32 @@ export function createJevBrowserServer({ env = process.env, configPath, fetchImp
   server.registerTool(
     "run_browser_flow",
     {
-      description: "Run a bounded screen flow in one warm Playwright session. Supports role/name and label, placeholder, title, text, test_id, CSS/XPath fallback selectors, relative row/dialog scopes, press keys, SPA readiness, per-step timeouts, same-origin page reuse, key-based typing, filtered network-idle and hidden-state waits, wait_for_text fail_on alerts, assertions, uploads, bounded downloads, axe audits, Playwright-indexed unnamed-control diagnostics split by initial/final screen, resolved locator and element evidence, and bounded same-origin JSON error bodies including chunked responses. All plan steps run before expected_outcome is checked unless stop_on_expected is enabled. Jev chooses among supplied plans; one plan skips the decision call when fast_path is enabled.",
+      description: "Run a bounded screen flow in a warm Playwright session. Continues the current same-origin page by default without repeating navigation. Supports role and label locators, exact row scopes, guarded dialog confirmation, network assertions, variables and extraction, AngularJS idle waits, field-value/enabled waits, dry runs before mutating steps, per-step timing and screenshots, Markdown/JUnit reports, uploads, downloads, accessibility audits, and clear navigation diagnostics. Jev chooses among supplied plans; one plan skips the decision call when fast_path is enabled.",
       inputSchema: {
         flow: z.string(),
         initial_url: z.string(),
         expected_outcome: z.string(),
         candidate_plans: z.record(z.string(), z.unknown()),
+        params: z.record(z.string(), z.unknown()).optional(),
         options: z.record(z.string(), z.unknown()).optional(),
       },
     },
-    async ({ flow, initial_url: initialUrl, expected_outcome: expectedOutcome, candidate_plans: candidatePlans, options }) => {
+    async ({ flow, initial_url: initialUrl, expected_outcome: expectedOutcome, candidate_plans: candidatePlans, params, options }) => {
       try {
         return toolText(await browserPool.runFlow(() => executeBrowserFlow({
           flow,
           initialUrl,
           expectedOutcome,
           candidatePlans,
+          params,
           options,
           settings,
           browserPool,
           fetchImpl,
+          serverVersion: packageManifest.version,
         })));
       } catch (error) {
-        return toolError(error);
+        return toolError(error, settings);
       }
     },
   );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diegosouzacdv/jev-browser-mcp",
-  "version": "0.4.2",
+  "version": "0.6.0",
   "description": "Portable MCP server for bounded Playwright screen flows selected by Jev",
   "license": "MIT",
   "repository": {