Merge pull request #41 from AgentDeskAI/feature/windows-compatibility

Improve Windows compatibility and connection reliability

Author: tedjames

browser-tools-mcp/mcp-server.ts

@@ -1,6 +1,6 @@
 {
   "name": "@agentdeskai/browser-tools-mcp",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "MCP (Model Context Protocol) server for browser tools integration",
   "main": "dist/mcp-server.js",
   "bin": {

browser-tools-mcp/package.json

@@ -11,6 +11,116 @@ import { IncomingMessage } from "http";
 import { Socket } from "net";
 import os from "os";
 
+/**
+ * Converts a file path to the appropriate format for the current platform
+ * Handles Windows, WSL, macOS and Linux path formats
+ *
+ * @param inputPath - The path to convert
+ * @returns The converted path appropriate for the current platform
+ */
+function convertPathForCurrentPlatform(inputPath: string): string {
+  const platform = os.platform();
+
+  // If no path provided, return as is
+  if (!inputPath) return inputPath;
+
+  console.log(`Converting path "${inputPath}" for platform: ${platform}`);
+
+  // Windows-specific conversion
+  if (platform === "win32") {
+    // Convert forward slashes to backslashes
+    return inputPath.replace(/\//g, "\\");
+  }
+
+  // Linux/Mac-specific conversion
+  if (platform === "linux" || platform === "darwin") {
+    // Check if this is a Windows UNC path (starts with \\)
+    if (inputPath.startsWith("\\\\") || inputPath.includes("\\")) {
+      // Check if this is a WSL path (contains wsl.localhost or wsl$)
+      if (inputPath.includes("wsl.localhost") || inputPath.includes("wsl$")) {
+        // Extract the path after the distribution name
+        // Handle both \\wsl.localhost\Ubuntu\path and \\wsl$\Ubuntu\path formats
+        const parts = inputPath.split("\\").filter((part) => part.length > 0);
+        console.log("Path parts:", parts);
+
+        // Find the index after the distribution name
+        const distNames = [
+          "Ubuntu",
+          "Debian",
+          "kali",
+          "openSUSE",
+          "SLES",
+          "Fedora",
+        ];
+
+        // Find the distribution name in the path
+        let distIndex = -1;
+        for (const dist of distNames) {
+          const index = parts.findIndex(
+            (part) => part === dist || part.toLowerCase() === dist.toLowerCase()
+          );
+          if (index !== -1) {
+            distIndex = index;
+            break;
+          }
+        }
+
+        if (distIndex !== -1 && distIndex + 1 < parts.length) {
+          // Reconstruct the path as a native Linux path
+          const linuxPath = "/" + parts.slice(distIndex + 1).join("/");
+          console.log(
+            `Converted Windows WSL path "${inputPath}" to Linux path "${linuxPath}"`
+          );
+          return linuxPath;
+        }
+
+        // If we couldn't find a distribution name but it's clearly a WSL path,
+        // try to extract everything after wsl.localhost or wsl$
+        const wslIndex = parts.findIndex(
+          (part) =>
+            part === "wsl.localhost" ||
+            part === "wsl$" ||
+            part.toLowerCase() === "wsl.localhost" ||
+            part.toLowerCase() === "wsl$"
+        );
+
+        if (wslIndex !== -1 && wslIndex + 2 < parts.length) {
+          // Skip the WSL prefix and distribution name
+          const linuxPath = "/" + parts.slice(wslIndex + 2).join("/");
+          console.log(
+            `Converted Windows WSL path "${inputPath}" to Linux path "${linuxPath}"`
+          );
+          return linuxPath;
+        }
+      }
+
+      // For non-WSL Windows paths, just normalize the slashes
+      const normalizedPath = inputPath
+        .replace(/\\\\/g, "/")
+        .replace(/\\/g, "/");
+      console.log(
+        `Converted Windows UNC path "${inputPath}" to "${normalizedPath}"`
+      );
+      return normalizedPath;
+    }
+
+    // Handle Windows drive letters (e.g., C:\path\to\file)
+    if (/^[A-Z]:\\/i.test(inputPath)) {
+      // Convert Windows drive path to Linux/Mac compatible path
+      const normalizedPath = inputPath
+        .replace(/^[A-Z]:\\/i, "/")
+        .replace(/\\/g, "/");
+      console.log(
+        `Converted Windows drive path "${inputPath}" to "${normalizedPath}"`
+      );
+      return normalizedPath;
+    }
+  }
+
+  // Return the original path if no conversion was needed or possible
+  return inputPath;
+}
+
 // Function to get default downloads folder
 function getDefaultDownloadsFolder(): string {
   const homeDir = os.homedir();
@@ -36,6 +146,8 @@ let currentSettings = {
   stringSizeLimit: 500,
   maxLogSize: 20000,
   screenshotPath: getDefaultDownloadsFolder(),
+  // Add server host configuration
+  serverHost: process.env.SERVER_HOST || "0.0.0.0", // Default to all interfaces
 };
 
 // Add new storage for selected element
@@ -49,9 +161,68 @@ interface ScreenshotCallback {
 
 const screenshotCallbacks = new Map<string, ScreenshotCallback>();
 
-const app = express();
-const PORT = 3025;
+// Function to get available port starting with the given port
+async function getAvailablePort(
+  startPort: number,
+  maxAttempts: number = 10
+): Promise<number> {
+  let currentPort = startPort;
+  let attempts = 0;
+
+  while (attempts < maxAttempts) {
+    try {
+      // Try to create a server on the current port
+      // We'll use a raw Node.js net server for just testing port availability
+      await new Promise<void>((resolve, reject) => {
+        const testServer = require("net").createServer();
+
+        // Handle errors (e.g., port in use)
+        testServer.once("error", (err: any) => {
+          if (err.code === "EADDRINUSE") {
+            console.log(`Port ${currentPort} is in use, trying next port...`);
+            currentPort++;
+            attempts++;
+            resolve(); // Continue to next iteration
+          } else {
+            reject(err); // Different error, propagate it
+          }
+        });
+
+        // If we can listen, the port is available
+        testServer.once("listening", () => {
+          // Make sure to close the server to release the port
+          testServer.close(() => {
+            console.log(`Found available port: ${currentPort}`);
+            resolve();
+          });
+        });
 
+        // Try to listen on the current port
+        testServer.listen(currentPort, currentSettings.serverHost);
+      });
+
+      // If we reach here without incrementing the port, it means the port is available
+      return currentPort;
+    } catch (error: any) {
+      console.error(`Error checking port ${currentPort}:`, error);
+      // For non-EADDRINUSE errors, try the next port
+      currentPort++;
+      attempts++;
+    }
+  }
+
+  // If we've exhausted all attempts, throw an error
+  throw new Error(
+    `Could not find an available port after ${maxAttempts} attempts starting from ${startPort}`
+  );
+}
+
+// Start with requested port and find an available one
+const REQUESTED_PORT = parseInt(process.env.PORT || "3025", 10);
+let PORT = REQUESTED_PORT;
+
+// Create application and initialize middleware
+const app = express();
 app.use(cors());
 // Increase JSON body parser limit to 50MB to handle large screenshots
 app.use(bodyParser.json({ limit: "50mb" }));
@@ -306,6 +477,16 @@ app.get("/.port", (req, res) => {
   res.send(PORT.toString());
 });
 
+// Add new identity endpoint with a unique signature
+app.get("/.identity", (req, res) => {
+  res.json({
+    port: PORT,
+    name: "browser-tools-server",
+    version: "1.1.0",
+    signature: "mcp-browser-connector-24x7",
+  });
+});
+
 // Add function to clear all logs
 function clearAllLogs() {
   console.log("Wiping all logs...");
@@ -627,29 +808,62 @@ export class BrowserConnector {
       console.log("Browser Connector: Received screenshot data, saving...");
       console.log("Browser Connector: Custom path from extension:", customPath);
 
-      // Determine target path
-      const targetPath =
-        customPath ||
-        currentSettings.screenshotPath ||
-        getDefaultDownloadsFolder();
+      // Always prioritize the path from the Chrome extension
+      let targetPath = customPath;
+
+      // If no path provided by extension, fall back to defaults
+      if (!targetPath) {
+        targetPath =
+          currentSettings.screenshotPath || getDefaultDownloadsFolder();
+      }
+
+      // Convert the path for the current platform
+      targetPath = convertPathForCurrentPlatform(targetPath);
+
       console.log(`Browser Connector: Using path: ${targetPath}`);
 
       if (!base64Data) {
         throw new Error("No screenshot data received from Chrome extension");
       }
 
-      fs.mkdirSync(targetPath, { recursive: true });
+      try {
+        fs.mkdirSync(targetPath, { recursive: true });
+        console.log(`Browser Connector: Created directory: ${targetPath}`);
+      } catch (err) {
+        console.error(
+          `Browser Connector: Error creating directory: ${targetPath}`,
+          err
+        );
+        throw new Error(
+          `Failed to create screenshot directory: ${
+            err instanceof Error ? err.message : String(err)
+          }`
+        );
+      }
 
       const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
       const filename = `screenshot-${timestamp}.png`;
       const fullPath = path.join(targetPath, filename);
+      console.log(`Browser Connector: Full screenshot path: ${fullPath}`);
 
       // Remove the data:image/png;base64, prefix if present
       const cleanBase64 = base64Data.replace(/^data:image\/png;base64,/, "");
 
       // Save the file
-      fs.writeFileSync(fullPath, cleanBase64, "base64");
-      console.log(`Browser Connector: Screenshot saved to: ${fullPath}`);
+      try {
+        fs.writeFileSync(fullPath, cleanBase64, "base64");
+        console.log(`Browser Connector: Screenshot saved to: ${fullPath}`);
+      } catch (err) {
+        console.error(
+          `Browser Connector: Error saving screenshot to: ${fullPath}`,
+          err
+        );
+        throw new Error(
+          `Failed to save screenshot: ${
+            err instanceof Error ? err.message : String(err)
+          }`
+        );
+      }
 
       res.json({
         path: fullPath,
@@ -669,18 +883,88 @@ export class BrowserConnector {
   }
 }
 
-// Move the server creation before BrowserConnector instantiation
-const server = app.listen(PORT, () => {
-  console.log(`Aggregator listening on http://127.0.0.1:${PORT}`);
-});
+// Use an async IIFE to allow for async/await in the initial setup
+(async () => {
+  try {
+    console.log(`Starting Browser Tools Server...`);
+    console.log(`Requested port: ${REQUESTED_PORT}`);
 
-// Initialize the browser connector with the existing app AND server
-const browserConnector = new BrowserConnector(app, server);
+    // Find an available port
+    try {
+      PORT = await getAvailablePort(REQUESTED_PORT);
 
-// Handle shutdown gracefully
-process.on("SIGINT", () => {
-  server.close(() => {
-    console.log("Server shut down");
-    process.exit(0);
-  });
+      if (PORT !== REQUESTED_PORT) {
+        console.log(`\n====================================`);
+        console.log(`NOTICE: Requested port ${REQUESTED_PORT} was in use.`);
+        console.log(`Using port ${PORT} instead.`);
+        console.log(`====================================\n`);
+      }
+    } catch (portError) {
+      console.error(`Failed to find an available port:`, portError);
+      process.exit(1);
+    }
+
+    // Create the server with the available port
+    const server = app.listen(PORT, currentSettings.serverHost, () => {
+      console.log(`\n=== Browser Tools Server Started ===`);
+      console.log(
+        `Aggregator listening on http://${currentSettings.serverHost}:${PORT}`
+      );
+
+      if (PORT !== REQUESTED_PORT) {
+        console.log(
+          `NOTE: Using fallback port ${PORT} instead of requested port ${REQUESTED_PORT}`
+        );
+      }
+
+      // Log all available network interfaces for easier discovery
+      const networkInterfaces = os.networkInterfaces();
+      console.log("\nAvailable on the following network addresses:");
+
+      Object.keys(networkInterfaces).forEach((interfaceName) => {
+        const interfaces = networkInterfaces[interfaceName];
+        if (interfaces) {
+          interfaces.forEach((iface) => {
+            if (!iface.internal && iface.family === "IPv4") {
+              console.log(`  - http://${iface.address}:${PORT}`);
+            }
+          });
+        }
+      });
+
+      console.log(`\nFor local access use: http://localhost:${PORT}`);
+    });
+
+    // Handle server startup errors
+    server.on("error", (err: any) => {
+      if (err.code === "EADDRINUSE") {
+        console.error(
+          `ERROR: Port ${PORT} is still in use, despite our checks!`
+        );
+        console.error(
+          `This might indicate another process started using this port after our check.`
+        );
+      } else {
+        console.error(`Server error:`, err);
+      }
+      process.exit(1);
+    });
+
+    // Initialize the browser connector with the existing app AND server
+    const browserConnector = new BrowserConnector(app, server);
+
+    // Handle shutdown gracefully
+    process.on("SIGINT", () => {
+      server.close(() => {
+        console.log("Server shut down");
+        process.exit(0);
+      });
+    });
+  } catch (error) {
+    console.error("Failed to start server:", error);
+    process.exit(1);
+  }
+})().catch((err) => {
+  console.error("Unhandled error during server startup:", err);
+  process.exit(1);
 });