@squidlerio/squidler-mcp 1.0.0

package/dist/mcp-proxy-server.js

@@ -0,0 +1,532 @@
+#!/usr/bin/env node
+import {
+  VERSION,
+  authenticateWithOAuth,
+  downloadChrome,
+  loadStoredAuth
+} from "./cli-w466m345.js";
+
+// src/mcp-proxy-server.ts
+import { setMaxListeners } from "events";
+
+// src/mcp-proxy.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema,
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/cdp/session.ts
+import WebSocket from "ws";
+
+// src/chrome/launcher.ts
+import { spawn } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import * as net from "net";
+async function findFreePort() {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.unref();
+    server.on("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (address && typeof address === "object") {
+        const port = address.port;
+        server.close(() => resolve(port));
+      } else {
+        reject(new Error("Could not get port"));
+      }
+    });
+  });
+}
+function extractWsEndpoint(process2) {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error("Timeout waiting for Chrome to start"));
+    }, 30000);
+    const pattern = /DevTools listening on (ws:\/\/[^\s]+)/;
+    const onData = (data) => {
+      const text = data.toString();
+      const match = pattern.exec(text);
+      if (match) {
+        clearTimeout(timeout);
+        process2.stderr?.off("data", onData);
+        process2.stdout?.off("data", onData);
+        resolve(match[1]);
+      }
+    };
+    process2.stderr?.on("data", onData);
+    process2.stdout?.on("data", onData);
+    process2.on("error", (err) => {
+      clearTimeout(timeout);
+      reject(err);
+    });
+    process2.on("exit", (code) => {
+      clearTimeout(timeout);
+      if (code !== 0) {
+        reject(new Error(`Chrome exited with code ${code}`));
+      }
+    });
+  });
+}
+async function launchChrome(options = {}) {
+  let executablePath = options.executablePath;
+  if (!executablePath) {
+    const chromeInfo = await downloadChrome();
+    executablePath = chromeInfo.executablePath;
+  }
+  const port = options.port || await findFreePort();
+  const userDataDir = options.userDataDir || fs.mkdtempSync(path.join(os.tmpdir(), "squidler-chrome-"));
+  const args = [
+    `--remote-debugging-port=${port}`,
+    "--remote-debugging-address=127.0.0.1",
+    `--user-data-dir=${userDataDir}`,
+    "--no-first-run",
+    "--no-default-browser-check",
+    "--disable-background-networking",
+    "--disable-background-timer-throttling",
+    "--disable-backgrounding-occluded-windows",
+    "--disable-breakpad",
+    "--disable-client-side-phishing-detection",
+    "--disable-component-update",
+    "--disable-default-apps",
+    "--disable-dev-shm-usage",
+    "--disable-domain-reliability",
+    "--disable-extensions",
+    "--disable-hang-monitor",
+    "--disable-ipc-flooding-protection",
+    "--disable-popup-blocking",
+    "--disable-prompt-on-repost",
+    "--disable-renderer-backgrounding",
+    "--disable-sync",
+    "--disable-translate",
+    "--disable-web-security",
+    "--disable-site-isolation-trials",
+    "--metrics-recording-only",
+    "--mute-audio",
+    "--no-sandbox",
+    "--safebrowsing-disable-auto-update",
+    `--window-size=${options.width || 1920},${options.height || 1080}`
+  ];
+  if (options.headless !== false) {
+    args.push("--headless=new");
+  }
+  if (options.args) {
+    args.push(...options.args);
+  }
+  console.error(`Launching Chrome on port ${port}...`);
+  const chromeProcess = spawn(executablePath, args, {
+    stdio: ["pipe", "pipe", "pipe"],
+    detached: false
+  });
+  const wsEndpoint = await extractWsEndpoint(chromeProcess);
+  console.error(`Chrome started: ${wsEndpoint}`);
+  const close = async () => {
+    return new Promise((resolve) => {
+      if (chromeProcess.killed) {
+        resolve();
+        return;
+      }
+      chromeProcess.on("exit", () => {
+        try {
+          fs.rmSync(userDataDir, { recursive: true, force: true });
+        } catch {}
+        resolve();
+      });
+      chromeProcess.kill("SIGTERM");
+      setTimeout(() => {
+        if (!chromeProcess.killed) {
+          chromeProcess.kill("SIGKILL");
+        }
+      }, 5000);
+    });
+  };
+  const pid = chromeProcess.pid;
+  if (pid === undefined) {
+    throw new Error("Chrome process started but has no PID - this should not happen");
+  }
+  return {
+    wsEndpoint,
+    pid,
+    port,
+    process: chromeProcess,
+    userDataDir,
+    close
+  };
+}
+
+// src/cdp/session.ts
+var activeSession = null;
+async function createProxySession(cdpProxyBaseUrl) {
+  const url = `${cdpProxyBaseUrl.replace(/^ws/, "http")}/session`;
+  const response = await fetch(url, { method: "POST" });
+  if (!response.ok) {
+    throw new Error(`Failed to create CDP proxy session: ${response.status} ${response.statusText}`);
+  }
+  return await response.json();
+}
+function waitForOpen(ws, name) {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error(`Timeout connecting to ${name}`));
+    }, 30000);
+    ws.on("open", () => {
+      clearTimeout(timeout);
+      resolve();
+    });
+    ws.on("error", (err) => {
+      clearTimeout(timeout);
+      reject(new Error(`Failed to connect to ${name}: ${err.message}`));
+    });
+  });
+}
+async function startSession(cdpProxyBaseUrl, chromeOptions) {
+  if (activeSession) {
+    throw new Error("Session already active. Stop it first.");
+  }
+  console.error("Querying CDP proxy for Chrome version...");
+  const versionsUrl = `${cdpProxyBaseUrl.replace(/^ws/, "http")}/versions`;
+  const versionsResponse = await fetch(versionsUrl);
+  if (!versionsResponse.ok) {
+    throw new Error(`Failed to query CDP proxy versions: ${versionsResponse.status}`);
+  }
+  const versions = await versionsResponse.json();
+  console.error(`Required Chrome version: ${versions.chrome}`);
+  if (versions.mcpServer !== VERSION) {
+    console.error(`WARNING: CDP proxy expects MCP server ${versions.mcpServer}, running ${VERSION}. Please update your MCP server.`);
+  }
+  const chromeInfo = await downloadChrome({ version: versions.chrome });
+  console.error(`Chrome ready: ${chromeInfo.version}`);
+  console.error("Creating CDP proxy session...");
+  const sessionInfo = await createProxySession(cdpProxyBaseUrl);
+  console.error(`Session created: ${sessionInfo.sessionId}`);
+  console.error("Launching local Chrome...");
+  const chrome = await launchChrome({
+    ...chromeOptions,
+    executablePath: chromeInfo.executablePath
+  });
+  console.error(`Chrome launched on port ${chrome.port}`);
+  let chromeWs;
+  let proxyWs;
+  try {
+    console.error(`Connecting to Chrome: ${chrome.wsEndpoint}`);
+    chromeWs = new WebSocket(chrome.wsEndpoint);
+    await waitForOpen(chromeWs, "Chrome");
+    console.error(`Connecting to CDP proxy: ${sessionInfo.localUrl}`);
+    proxyWs = new WebSocket(sessionInfo.localUrl);
+    await waitForOpen(proxyWs, "CDP proxy");
+  } catch (error) {
+    console.error("Failed to connect WebSockets, cleaning up Chrome...");
+    await chrome.close();
+    throw error;
+  }
+  proxyWs.on("message", (data, isBinary) => {
+    if (chromeWs.readyState === WebSocket.OPEN) {
+      chromeWs.send(data, { binary: isBinary });
+    }
+  });
+  chromeWs.on("message", (data, isBinary) => {
+    if (proxyWs.readyState === WebSocket.OPEN) {
+      proxyWs.send(data, { binary: isBinary });
+    }
+  });
+  proxyWs.on("close", () => {
+    console.error("CDP proxy connection closed");
+  });
+  chromeWs.on("close", () => {
+    console.error("Chrome connection closed");
+  });
+  proxyWs.on("error", (err) => {
+    console.error("CDP proxy WebSocket error:", err.message);
+  });
+  chromeWs.on("error", (err) => {
+    console.error("Chrome WebSocket error:", err.message);
+  });
+  const pingInterval = setInterval(() => {
+    if (proxyWs.readyState === WebSocket.OPEN)
+      proxyWs.ping();
+    if (chromeWs.readyState === WebSocket.OPEN)
+      chromeWs.ping();
+  }, 30000);
+  activeSession = {
+    sessionId: sessionInfo.sessionId,
+    localUrl: sessionInfo.localUrl,
+    remoteUrl: sessionInfo.remoteUrl,
+    chrome,
+    chromeWs,
+    proxyWs,
+    pingInterval,
+    headless: chromeOptions?.headless !== false
+  };
+  console.error("CDP session established");
+  return activeSession;
+}
+async function stopSession() {
+  if (!activeSession)
+    return;
+  const session = activeSession;
+  activeSession = null;
+  console.error("Stopping CDP session...");
+  if (session.pingInterval) {
+    clearInterval(session.pingInterval);
+  }
+  try {
+    session.proxyWs?.close(1000, "Session stopped");
+  } catch {}
+  try {
+    session.chromeWs?.close(1000, "Session stopped");
+  } catch {}
+  try {
+    await session.chrome?.close();
+  } catch {}
+  console.error("CDP session stopped");
+}
+function getActiveSession() {
+  return activeSession;
+}
+
+// src/mcp-proxy.ts
+function toolResult(text, isError) {
+  return {
+    content: [{ type: "text", text }],
+    ...isError ? { isError: true } : {}
+  };
+}
+function deriveCdpProxyUrl(apiUrl) {
+  const url = new URL(apiUrl);
+  const parts = url.hostname.split(".");
+  if (["api", "mcp"].includes(parts[0])) {
+    parts[0] = "cdp-proxy";
+  } else {
+    parts.splice(0, 0, "cdp-proxy");
+  }
+  return `wss://${parts.join(".")}`;
+}
+async function startMCPProxy(options) {
+  const { apiUrl } = options;
+  const mcpUrl = apiUrl;
+  const cdpProxyUrl = deriveCdpProxyUrl(apiUrl);
+  let localChromeSettings = null;
+  let remoteClient = null;
+  let resolvedApiKey;
+  async function getApiKey() {
+    if (resolvedApiKey)
+      return resolvedApiKey;
+    if (options.apiKey) {
+      resolvedApiKey = options.apiKey;
+    } else if (options.resolveApiKey) {
+      resolvedApiKey = await options.resolveApiKey();
+    } else {
+      throw new Error("No API key configured. Set SQUIDLER_API_KEY or run: squidler-mcp login");
+    }
+    return resolvedApiKey;
+  }
+  async function connectRemote() {
+    const apiKey = await getApiKey();
+    const transport = new StreamableHTTPClientTransport(new URL(mcpUrl), {
+      requestInit: {
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "X-Squidler-Client": "npm-proxy"
+        }
+      }
+    });
+    const client = new Client({
+      name: "squidler-local-proxy",
+      version: VERSION
+    });
+    client.onerror = (error) => {
+      console.error("Remote MCP client error:", error.message);
+    };
+    client.onclose = () => {
+      console.error("Remote MCP connection closed");
+    };
+    await client.connect(transport);
+    console.error("Connected to remote MCP server");
+    return client;
+  }
+  async function ensureRemote() {
+    if (!remoteClient) {
+      remoteClient = await connectRemote();
+    }
+    return remoteClient;
+  }
+  async function withReconnect(fn) {
+    const client = await ensureRemote();
+    try {
+      return await fn(client);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      if (msg.includes("Session not found") || msg.includes("fetch failed")) {
+        console.error(`Remote session lost (${msg}), reconnecting...`);
+        try {
+          await client.close();
+        } catch {}
+        remoteClient = await connectRemote();
+        return await fn(remoteClient);
+      }
+      throw error;
+    }
+  }
+  async function runWithLocalChrome(request) {
+    const existingSession = getActiveSession();
+    if (existingSession) {
+      console.error("Recycling CDP session for clean test environment...");
+      await stopSession();
+    }
+    const freshSession = await startSession(cdpProxyUrl, {
+      headless: localChromeSettings.headless
+    });
+    return await withReconnect((c) => c.callTool({
+      name: request.params.name,
+      arguments: {
+        ...request.params.arguments,
+        cdpProxyUrl: freshSession.remoteUrl
+      }
+    }));
+  }
+  const localServer = new Server({ name: "squidler", version: VERSION }, {
+    capabilities: {
+      tools: {},
+      resources: {},
+      prompts: {}
+    }
+  });
+  localServer.setRequestHandler(ListToolsRequestSchema, async () => {
+    const remoteResult = await withReconnect((c) => c.listTools());
+    const localTools = [
+      {
+        name: "local_session_start",
+        description: "Start a local Chrome session for testing localhost URLs. Launches Chrome and connects it to the CDP proxy so cloud tests can control it.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            headless: {
+              type: "boolean",
+              description: "Run Chrome in headless mode (default: true)"
+            }
+          }
+        }
+      },
+      {
+        name: "local_session_stop",
+        description: "Stop the local Chrome session and clean up resources.",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "local_session_status",
+        description: "Check the status of the local Chrome session.",
+        inputSchema: { type: "object", properties: {} }
+      }
+    ];
+    return { tools: [...remoteResult.tools, ...localTools] };
+  });
+  localServer.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name } = request.params;
+    switch (name) {
+      case "local_session_start": {
+        const headless = request.params.arguments?.headless !== false;
+        localChromeSettings = { headless };
+        return toolResult(JSON.stringify({
+          status: "enabled",
+          headless,
+          message: "Local Chrome mode enabled. Tests will now run against your local Chrome."
+        }));
+      }
+      case "local_session_stop": {
+        localChromeSettings = null;
+        await stopSession();
+        return toolResult(JSON.stringify({
+          status: "stopped",
+          message: "Local Chrome mode disabled and session stopped."
+        }));
+      }
+      case "local_session_status": {
+        const session = getActiveSession();
+        return toolResult(JSON.stringify({
+          localChrome: localChromeSettings ? "enabled" : "disabled",
+          ...localChromeSettings ?? {},
+          session: session ? { status: "active", sessionId: session.sessionId } : { status: "inactive" }
+        }));
+      }
+      case "test_case_run": {
+        if (localChromeSettings) {
+          return await runWithLocalChrome(request);
+        }
+        break;
+      }
+    }
+    return await withReconnect((c) => c.callTool({
+      name,
+      arguments: request.params.arguments
+    }));
+  });
+  localServer.setRequestHandler(ListResourcesRequestSchema, async () => {
+    return await withReconnect((c) => c.listResources());
+  });
+  localServer.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    return await withReconnect((c) => c.readResource({ uri: request.params.uri }));
+  });
+  localServer.setRequestHandler(ListPromptsRequestSchema, async () => {
+    return await withReconnect((c) => c.listPrompts());
+  });
+  localServer.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    return await withReconnect((c) => c.getPrompt({
+      name: request.params.name,
+      arguments: request.params.arguments
+    }));
+  });
+  const stdioTransport = new StdioServerTransport;
+  await localServer.connect(stdioTransport);
+  console.error("Squidler MCP proxy started");
+  console.error(`Remote: ${apiUrl}`);
+  console.error(`CDP Proxy: ${cdpProxyUrl}`);
+  process.on("SIGINT", async () => {
+    await stopSession();
+    await localServer.close();
+    await remoteClient?.close();
+    process.exit(0);
+  });
+  process.on("SIGTERM", async () => {
+    await stopSession();
+    await localServer.close();
+    await remoteClient?.close();
+    process.exit(0);
+  });
+}
+
+// src/mcp-proxy-server.ts
+setMaxListeners(0);
+var SQUIDLER_API_URL = process.env.SQUIDLER_API_URL || "https://mcp.squidler.io";
+async function main() {
+  await startMCPProxy({
+    apiUrl: SQUIDLER_API_URL,
+    resolveApiKey: async () => {
+      const envKey = process.env.SQUIDLER_API_KEY;
+      if (envKey)
+        return envKey;
+      const stored = loadStoredAuth(SQUIDLER_API_URL);
+      if (stored) {
+        console.error("Using stored authentication token");
+        return stored.access_token;
+      }
+      console.error("No API key found. Starting browser authentication...");
+      const token = await authenticateWithOAuth(SQUIDLER_API_URL);
+      console.error("Authentication successful!");
+      return token;
+    }
+  });
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@squidlerio/squidler-mcp",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "Squidler MCP proxy - enables testing localhost URLs via local Chrome and CDP proxy",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/squidlerio/mcp.git"
+  },
+  "homepage": "https://github.com/squidlerio/mcp",
+  "bugs": {
+    "url": "https://github.com/squidlerio/mcp/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "squidler-mcp": "dist/cli.js",
+    "squidler-mcp-proxy": "dist/mcp-proxy-server.js"
+  },
+  "files": [
+    "dist",
+    "package.json",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "bun build src/cli.ts src/mcp-proxy-server.ts --outdir dist --target node --splitting --packages external",
+    "start": "bun src/cli.ts",
+    "mcp-proxy": "bun src/mcp-proxy-server.ts",
+    "clean": "rm -rf dist"
+  },
+  "keywords": [
+    "squidler",
+    "chrome",
+    "cdp",
+    "testing",
+    "localhost",
+    "mcp",
+    "model-context-protocol"
+  ],
+  "author": "Squidler",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "commander": "^12.1.0",
+    "unzipper": "^0.12.3",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "@types/unzipper": "^0.10.10",
+    "@types/ws": "^8.5.13"
+  }
+}