@diegosouzacdv/jev-browser-mcp 0.4.2 → 0.5.0

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

@@ -1,4 +1,5 @@
-import { spawnSync } from "node:child_process";
+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";
@@ -11,18 +12,27 @@ import { chooseNextAction, executeBrowserFlow } from "./flow.mjs";
 
 const browserPools = new Set();
 
-class BrowserPool {
+class BrowserPool {
   #settings;
   #contextPromise;
   #context;
   #browser;
   #page;
-  #startedAt;
+  #startedAt;
+  #navigationError;
   #flowQueue = Promise.resolve();
 
-  constructor(settings) {
+  constructor(settings) {
     this.#settings = settings;
-  }
+  }
+
+  getNavigationError() {
+    return this.#navigationError;
+  }
+
+  setNavigationError(error) {
+    this.#navigationError = error || undefined;
+  }
 
   async runFlow(work) {
     const previous = this.#flowQueue;
@@ -63,11 +73,15 @@ class BrowserPool {
         this.#context = await this.#browser.newContext();
         this.#page = await this.#context.newPage();
       }
-    } catch (error) {
-      this.#contextPromise = undefined;
-      throw new JevBrowserError(
-        `Could not start the configured ${channel} browser (${error?.name || "BrowserError"}); install it with jev-browser-mcp --install-browser`,
-      );
+    } catch (error) {
+      this.#contextPromise = undefined;
+      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`,
+      );
     }
   }
 
@@ -76,19 +90,68 @@ class BrowserPool {
     if (this.#browser) await this.#browser.close().catch(() => {});
     this.#context = undefined;
     this.#browser = undefined;
-    this.#page = undefined;
-    this.#contextPromise = 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 toolText(value) {
-  return { content: [{ type: "text", text: JSON.stringify(value) }] };
-}
+function toolError(error) {
+  const message = error instanceof JevBrowserError ? error.message : `Jev browser flow failed (${error?.name || "Error"})`;
+  return { isError: true, content: [{ type: "text", text: `[jev-browser ${packageManifest.version}] ${message}` }] };
+}
+
+function toolText(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 } = {}) {
   const settings = loadSettings({ env, ...(configPath ? { configPath } : {}) });
@@ -132,26 +195,29 @@ 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. Supports role and label locators, exact row scopes, guarded dialog confirmation, network assertions, variables and extraction, 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()),
-        options: z.record(z.string(), z.unknown()).optional(),
-      },
-    },
-    async ({ flow, initial_url: initialUrl, expected_outcome: expectedOutcome, candidate_plans: candidatePlans, options }) => {
+        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, params, options }) => {
       try {
         return toolText(await browserPool.runFlow(() => executeBrowserFlow({
           flow,
           initialUrl,
           expectedOutcome,
-          candidatePlans,
+          candidatePlans,
+          params,
           options,
           settings,
           browserPool,
-          fetchImpl,
+          fetchImpl,
+          serverVersion: packageManifest.version,
         })));
       } catch (error) {
         return toolError(error);

package/package.json

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