@mcp-use/inspector 0.3.1 → 0.3.2

package/dist/cli/inspect.cjs

@@ -0,0 +1,482 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/cli/inspect.ts
+var import_node_server = require("@hono/node-server");
+var import_hono2 = require("hono");
+var import_cors2 = require("hono/cors");
+var import_logger = require("hono/logger");
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_node_url = require("url");
+var import_node_child_process = require("child_process");
+var import_node_util = require("util");
+
+// src/server/favicon-proxy.ts
+var import_hono = require("hono");
+var import_cors = require("hono/cors");
+var app = new import_hono.Hono();
+app.use("*", (0, import_cors.cors)());
+var faviconCache = /* @__PURE__ */ new Map();
+var CACHE_TTL = 24 * 60 * 60 * 1e3;
+var MAX_CACHE_SIZE = 1e3;
+function cleanupCache() {
+  const now = Date.now();
+  for (const [key, entry] of faviconCache.entries()) {
+    if (now - entry.timestamp > entry.ttl) {
+      faviconCache.delete(key);
+    }
+  }
+}
+setInterval(cleanupCache, 60 * 60 * 1e3);
+function getCacheKey(url) {
+  try {
+    const urlObj = new URL(url);
+    return urlObj.hostname.toLowerCase();
+  } catch {
+    return url.toLowerCase();
+  }
+}
+app.get("/:url", async (c) => {
+  const url = c.req.param("url");
+  if (!url) {
+    return c.json({ error: "URL parameter is required" }, 400);
+  }
+  try {
+    const decodedUrl = decodeURIComponent(url);
+    let fullUrl = decodedUrl;
+    if (!decodedUrl.startsWith("http://") && !decodedUrl.startsWith("https://")) {
+      fullUrl = `https://${decodedUrl}`;
+    }
+    const urlObj = new URL(fullUrl);
+    const cacheKey = getCacheKey(fullUrl);
+    const cachedEntry = faviconCache.get(cacheKey);
+    if (cachedEntry && Date.now() - cachedEntry.timestamp < cachedEntry.ttl) {
+      return new Response(cachedEntry.data, {
+        headers: {
+          "Content-Type": cachedEntry.contentType,
+          "Cache-Control": "public, max-age=86400, immutable",
+          // Cache for 24 hours
+          "Access-Control-Allow-Origin": "*",
+          "X-Cache": "HIT"
+        }
+      });
+    }
+    const protocol = urlObj.protocol;
+    const baseDomain = `${protocol}//${urlObj.origin.split(".").slice(-2).join(".")}`;
+    const faviconUrls = [
+      `${urlObj.origin}/favicon.ico`,
+      `${urlObj.origin}/favicon.png`,
+      `${urlObj.origin}/apple-touch-icon.png`,
+      `${urlObj.origin}/icon.png`,
+      `${baseDomain}/favicon.ico`,
+      `${baseDomain}/favicon.png`,
+      `${baseDomain}/apple-touch-icon.png`,
+      `${baseDomain}/icon.png`
+    ];
+    for (const faviconUrl of faviconUrls) {
+      try {
+        const response = await fetch(faviconUrl, {
+          headers: {
+            "User-Agent": "Mozilla/5.0 (compatible; MCP-Inspector/1.0)"
+          }
+        });
+        if (response.ok) {
+          const contentType = response.headers.get("content-type") || "image/x-icon";
+          const buffer = await response.arrayBuffer();
+          if (faviconCache.size >= MAX_CACHE_SIZE) {
+            const entries = Array.from(faviconCache.entries());
+            entries.sort((a, b) => a[1].timestamp - b[1].timestamp);
+            const toRemove = entries.slice(0, Math.floor(MAX_CACHE_SIZE / 4));
+            toRemove.forEach(([key]) => faviconCache.delete(key));
+          }
+          faviconCache.set(cacheKey, {
+            data: buffer,
+            contentType,
+            timestamp: Date.now(),
+            ttl: CACHE_TTL
+          });
+          return new Response(buffer, {
+            headers: {
+              "Content-Type": contentType,
+              "Cache-Control": "public, max-age=86400, immutable",
+              // Cache for 24 hours
+              "Access-Control-Allow-Origin": "*",
+              "X-Cache": "MISS"
+            }
+          });
+        }
+      } catch {
+        continue;
+      }
+    }
+    return c.json({ error: "No favicon found" }, 404);
+  } catch (error) {
+    console.error("Favicon proxy error:", error);
+    return c.json({ error: "Invalid URL or fetch failed" }, 400);
+  }
+});
+app.get("/health", (c) => {
+  return c.json({ status: "ok", service: "favicon-proxy" });
+});
+var favicon_proxy_default = app;
+
+// src/server/mcp-inspector.ts
+var import_mcp_use = require("mcp-use");
+var MCPInspector = class {
+  constructor() {
+    __publicField(this, "servers", /* @__PURE__ */ new Map());
+    __publicField(this, "client");
+    this.client = new import_mcp_use.MCPClient();
+  }
+  async listServers() {
+    return Array.from(this.servers.values());
+  }
+  async connectToServer(url, command) {
+    const id = Date.now().toString();
+    const name = url || command || "Unknown Server";
+    try {
+      const serverName = `server_${id}`;
+      const serverConfig = url ? { url } : { command };
+      this.client.addServer(serverName, serverConfig);
+      const session = await this.client.createSession(serverName, true);
+      const tools = [
+        {
+          name: "get_weather",
+          description: "Get current weather for a location",
+          inputSchema: {
+            type: "object",
+            properties: {
+              location: { type: "string", description: "City name" }
+            },
+            required: ["location"]
+          }
+        }
+      ];
+      const resources = [
+        {
+          uri: "file:///home/user/documents",
+          name: "Documents",
+          description: "User documents directory",
+          mimeType: "application/x-directory"
+        }
+      ];
+      const server = {
+        id,
+        name,
+        url,
+        command,
+        status: "connected",
+        session,
+        tools,
+        resources,
+        lastActivity: /* @__PURE__ */ new Date()
+      };
+      this.servers.set(id, server);
+      return server;
+    } catch (error) {
+      const server = {
+        id,
+        name,
+        url,
+        command,
+        status: "error",
+        tools: [],
+        resources: [],
+        lastActivity: /* @__PURE__ */ new Date()
+      };
+      this.servers.set(id, server);
+      throw error;
+    }
+  }
+  async getServer(id) {
+    return this.servers.get(id) || null;
+  }
+  async executeTool(serverId, toolName, input) {
+    const server = this.servers.get(serverId);
+    if (!server || !server.session) {
+      throw new Error("Server not found or not connected");
+    }
+    try {
+      const result = {
+        tool: toolName,
+        input,
+        result: `Mock result for ${toolName} with input: ${JSON.stringify(input)}`,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      server.lastActivity = /* @__PURE__ */ new Date();
+      return result;
+    } catch (error) {
+      server.status = "error";
+      throw error;
+    }
+  }
+  async getServerTools(serverId) {
+    const server = this.servers.get(serverId);
+    if (!server) {
+      throw new Error("Server not found");
+    }
+    return server.tools;
+  }
+  async getServerResources(serverId) {
+    const server = this.servers.get(serverId);
+    if (!server) {
+      throw new Error("Server not found");
+    }
+    return server.resources;
+  }
+  async disconnectServer(serverId) {
+    const server = this.servers.get(serverId);
+    if (server && server.session) {
+      try {
+        await server.session.disconnect();
+      } catch (error) {
+        console.error("Error disconnecting from server:", error);
+      }
+    }
+    this.servers.delete(serverId);
+  }
+};
+
+// src/cli/inspect.ts
+var import_meta = {};
+var __filename = (0, import_node_url.fileURLToPath)(import_meta.url);
+var __dirname = (0, import_node_path.dirname)(__filename);
+var execAsync = (0, import_node_util.promisify)(import_node_child_process.exec);
+async function findAvailablePort(startPort2 = 8080) {
+  const net = await import("net");
+  for (let port = startPort2; port < startPort2 + 100; port++) {
+    try {
+      await new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.listen(port, () => {
+          server.close(() => resolve());
+        });
+        server.on("error", () => reject(new Error(`Port ${port} is in use`)));
+      });
+      return port;
+    } catch {
+      continue;
+    }
+  }
+  throw new Error(`No available port found starting from ${startPort2}`);
+}
+var args = process.argv.slice(2);
+var mcpUrl;
+var startPort = 8080;
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === "--url" && i + 1 < args.length) {
+    mcpUrl = args[i + 1];
+    i++;
+  } else if (args[i] === "--port" && i + 1 < args.length) {
+    startPort = parseInt(args[i + 1], 10);
+    i++;
+  } else if (args[i] === "--help" || args[i] === "-h") {
+    console.log(`
+MCP Inspector - Inspect and debug MCP servers
+
+Usage:
+  npx @mcp-use/inspect [options]
+
+Options:
+  --url <url>    MCP server URL to auto-connect to (e.g., http://localhost:3000/mcp)
+  --port <port>  Starting port to try (default: 8080, will find next available)
+  --help, -h     Show this help message
+
+Examples:
+  # Run inspector with auto-connect
+  npx @mcp-use/inspect --url http://localhost:3000/mcp
+
+  # Run starting from custom port
+  npx @mcp-use/inspect --url http://localhost:3000/mcp --port 9000
+
+  # Run without auto-connect
+  npx @mcp-use/inspect
+`);
+    process.exit(0);
+  }
+}
+var app2 = new import_hono2.Hono();
+app2.use("*", (0, import_cors2.cors)());
+app2.use("*", (0, import_logger.logger)());
+app2.route("/api/favicon", favicon_proxy_default);
+app2.get("/health", (c) => {
+  return c.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+});
+var mcpInspector = new MCPInspector();
+app2.get("/api/servers", async (c) => {
+  try {
+    const servers = await mcpInspector.listServers();
+    return c.json({ servers });
+  } catch {
+    return c.json({ error: "Failed to list servers" }, 500);
+  }
+});
+app2.post("/api/servers/connect", async (c) => {
+  try {
+    const { url, command } = await c.req.json();
+    const server = await mcpInspector.connectToServer(url, command);
+    return c.json({ server });
+  } catch {
+    return c.json({ error: "Failed to connect to server" }, 500);
+  }
+});
+app2.get("/api/servers/:id", async (c) => {
+  try {
+    const id = c.req.param("id");
+    const server = await mcpInspector.getServer(id);
+    if (!server) {
+      return c.json({ error: "Server not found" }, 404);
+    }
+    return c.json({ server });
+  } catch {
+    return c.json({ error: "Failed to get server details" }, 500);
+  }
+});
+app2.post("/api/servers/:id/tools/:toolName/execute", async (c) => {
+  try {
+    const id = c.req.param("id");
+    const toolName = c.req.param("toolName");
+    const input = await c.req.json();
+    const result = await mcpInspector.executeTool(id, toolName, input);
+    return c.json({ result });
+  } catch {
+    return c.json({ error: "Failed to execute tool" }, 500);
+  }
+});
+app2.get("/api/servers/:id/tools", async (c) => {
+  try {
+    const id = c.req.param("id");
+    const tools = await mcpInspector.getServerTools(id);
+    return c.json({ tools });
+  } catch {
+    return c.json({ error: "Failed to get server tools" }, 500);
+  }
+});
+app2.get("/api/servers/:id/resources", async (c) => {
+  try {
+    const id = c.req.param("id");
+    const resources = await mcpInspector.getServerResources(id);
+    return c.json({ resources });
+  } catch {
+    return c.json({ error: "Failed to get server resources" }, 500);
+  }
+});
+app2.delete("/api/servers/:id", async (c) => {
+  try {
+    const id = c.req.param("id");
+    await mcpInspector.disconnectServer(id);
+    return c.json({ success: true });
+  } catch {
+    return c.json({ error: "Failed to disconnect server" }, 500);
+  }
+});
+var clientDistPath = (0, import_node_path.join)(__dirname, "../../dist/client");
+if ((0, import_node_fs.existsSync)(clientDistPath)) {
+  app2.get("/inspector/assets/*", async (c) => {
+    const path = c.req.path.replace("/inspector/assets/", "assets/");
+    const fullPath = (0, import_node_path.join)(clientDistPath, path);
+    if ((0, import_node_fs.existsSync)(fullPath)) {
+      const content = await import("fs").then((fs) => fs.readFileSync(fullPath));
+      if (path.endsWith(".js")) {
+        c.header("Content-Type", "application/javascript");
+      } else if (path.endsWith(".css")) {
+        c.header("Content-Type", "text/css");
+      } else if (path.endsWith(".svg")) {
+        c.header("Content-Type", "image/svg+xml");
+      }
+      return c.body(content);
+    }
+    return c.notFound();
+  });
+  app2.get("/", (c) => {
+    return c.redirect("/inspector");
+  });
+  app2.get("*", (c) => {
+    const indexPath = (0, import_node_path.join)(clientDistPath, "index.html");
+    if ((0, import_node_fs.existsSync)(indexPath)) {
+      const content = import("fs").then((fs) => fs.readFileSync(indexPath, "utf-8"));
+      return c.html(content);
+    }
+    return c.html(`
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <title>MCP Inspector</title>
+        </head>
+        <body>
+          <h1>MCP Inspector</h1>
+          <p>Client files not found. Please run 'yarn build' to build the UI.</p>
+          <p>API is available at <a href="/api/servers">/api/servers</a></p>
+        </body>
+      </html>
+    `);
+  });
+} else {
+  console.warn(`\u26A0\uFE0F  MCP Inspector client files not found at ${clientDistPath}`);
+  console.warn(`   Run 'yarn build' in the inspector package to build the UI`);
+  app2.get("*", (c) => {
+    return c.html(`
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <title>MCP Inspector</title>
+        </head>
+        <body>
+          <h1>MCP Inspector</h1>
+          <p>Client files not found. Please run 'yarn build' to build the UI.</p>
+          <p>API is available at <a href="/api/servers">/api/servers</a></p>
+        </body>
+      </html>
+    `);
+  });
+}
+async function startServer() {
+  try {
+    const port = await findAvailablePort(startPort);
+    (0, import_node_server.serve)({
+      fetch: app2.fetch,
+      port
+    });
+    console.log(`\u{1F680} MCP Inspector running on http://localhost:${port}`);
+    if (mcpUrl) {
+      console.log(`\u{1F4E1} Auto-connecting to: ${mcpUrl}`);
+    }
+    try {
+      const command = process.platform === "win32" ? "start" : process.platform === "darwin" ? "open" : "xdg-open";
+      await execAsync(`${command} http://localhost:${port}`);
+      console.log(`\u{1F310} Browser opened automatically`);
+    } catch (error) {
+      console.log(`\u{1F310} Please open http://localhost:${port} in your browser`);
+    }
+    return { port, fetch: app2.fetch };
+  } catch (error) {
+    console.error("Failed to start server:", error);
+    process.exit(1);
+  }
+}
+startServer();