@mcpjam/inspector 0.8.2 → 0.9.0

package/dist/server/index.js

@@ -0,0 +1,1101 @@
+// index.ts
+import { serve } from "@hono/node-server";
+import { Hono as Hono8 } from "hono";
+import { cors } from "hono/cors";
+import { logger } from "hono/logger";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { readFileSync } from "fs";
+import { join } from "path";
+
+// routes/mcp/index.ts
+import { Hono as Hono7 } from "hono";
+
+// routes/mcp/connect.ts
+import { Hono } from "hono";
+
+// utils/mcp-utils.ts
+import { MCPClient } from "@mastra/mcp";
+function validateServerConfig(serverConfig) {
+  if (!serverConfig) {
+    return {
+      success: false,
+      error: {
+        message: "Server configuration is required",
+        status: 400
+      }
+    };
+  }
+  const config = { ...serverConfig };
+  if (config.url) {
+    try {
+      if (typeof config.url === "string") {
+        config.url = new URL(config.url);
+      } else if (typeof config.url === "object" && !config.url.href) {
+        return {
+          success: false,
+          error: {
+            message: "Invalid URL configuration",
+            status: 400
+          }
+        };
+      }
+      if (config.oauth?.access_token) {
+        const authHeaders = {
+          Authorization: `Bearer ${config.oauth.access_token}`,
+          ...config.requestInit?.headers || {}
+        };
+        config.requestInit = {
+          ...config.requestInit,
+          headers: authHeaders
+        };
+        config.eventSourceInit = {
+          fetch(input, init) {
+            const headers = new Headers(init?.headers || {});
+            headers.set(
+              "Authorization",
+              `Bearer ${config.oauth.access_token}`
+            );
+            if (config.requestInit?.headers) {
+              const requestHeaders = new Headers(config.requestInit.headers);
+              requestHeaders.forEach((value, key) => {
+                if (key.toLowerCase() !== "authorization") {
+                  headers.set(key, value);
+                }
+              });
+            }
+            return fetch(input, {
+              ...init,
+              headers
+            });
+          }
+        };
+      } else if (config.requestInit?.headers) {
+        config.eventSourceInit = {
+          fetch(input, init) {
+            const headers = new Headers(init?.headers || {});
+            const requestHeaders = new Headers(config.requestInit.headers);
+            requestHeaders.forEach((value, key) => {
+              headers.set(key, value);
+            });
+            return fetch(input, {
+              ...init,
+              headers
+            });
+          }
+        };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: {
+          message: `Invalid URL format: ${error}`,
+          status: 400
+        }
+      };
+    }
+  }
+  return {
+    success: true,
+    config
+  };
+}
+function createMCPClient(config, id) {
+  return new MCPClient({
+    id,
+    servers: {
+      server: config
+    }
+  });
+}
+var validateMultipleServerConfigs = (serverConfigs) => {
+  if (!serverConfigs || Object.keys(serverConfigs).length === 0) {
+    return {
+      success: false,
+      error: {
+        message: "At least one server configuration is required",
+        status: 400
+      }
+    };
+  }
+  const validConfigs = {};
+  const errors = {};
+  let hasErrors = false;
+  for (const [serverName, serverConfig] of Object.entries(serverConfigs)) {
+    const validationResult = validateServerConfig(serverConfig);
+    if (validationResult.success && validationResult.config) {
+      validConfigs[serverName] = validationResult.config;
+    } else {
+      hasErrors = true;
+      let errorMessage = "Configuration validation failed";
+      if (validationResult.error) {
+        errorMessage = validationResult.error.message;
+      }
+      errors[serverName] = errorMessage;
+    }
+  }
+  if (!hasErrors) {
+    return {
+      success: true,
+      validConfigs
+    };
+  }
+  if (Object.keys(validConfigs).length > 0) {
+    return {
+      success: false,
+      validConfigs,
+      errors
+    };
+  }
+  return {
+    success: false,
+    errors,
+    error: {
+      message: "All server configurations failed validation",
+      status: 400
+    }
+  };
+};
+function createMCPClientWithMultipleConnections(serverConfigs) {
+  const normalizedConfigs = {};
+  for (const [serverName, config] of Object.entries(serverConfigs)) {
+    const normalizedName = normalizeServerConfigName(serverName);
+    normalizedConfigs[normalizedName] = config;
+  }
+  return new MCPClient({
+    id: `chat-${Date.now()}`,
+    servers: normalizedConfigs
+  });
+}
+function normalizeServerConfigName(serverName) {
+  return serverName.toLowerCase().replace(/[\s\-]+/g, "_").replace(/[^a-z0-9_]/g, "");
+}
+
+// routes/mcp/connect.ts
+var connect = new Hono();
+connect.post("/", async (c) => {
+  try {
+    const { serverConfig } = await c.req.json();
+    const validation = validateServerConfig(serverConfig);
+    if (!validation.success) {
+      const error = validation.error;
+      return c.json(
+        {
+          success: false,
+          error: error.message
+        },
+        error.status
+      );
+    }
+    let client;
+    try {
+      client = createMCPClient(validation.config, `test-${Date.now()}`);
+    } catch (error) {
+      return c.json(
+        {
+          success: false,
+          error: `Failed to create a MCP client. Please double check your server configuration: ${JSON.stringify(serverConfig)}`,
+          details: error instanceof Error ? error.message : "Unknown error"
+        },
+        500
+      );
+    }
+    try {
+      await client.getTools();
+      await client.disconnect();
+      return c.json({
+        success: true
+      });
+    } catch (error) {
+      return c.json(
+        {
+          success: false,
+          error: `MCP configuration is invalid. Please double check your server configuration: ${JSON.stringify(serverConfig)}`,
+          details: error instanceof Error ? error.message : "Unknown error"
+        },
+        500
+      );
+    }
+  } catch (error) {
+    return c.json(
+      {
+        success: false,
+        error: "Failed to parse request body",
+        details: error instanceof Error ? error.message : "Unknown error"
+      },
+      400
+    );
+  }
+});
+var connect_default = connect;
+
+// routes/mcp/tools.ts
+import { Hono as Hono2 } from "hono";
+import { zodToJsonSchema } from "zod-to-json-schema";
+var tools = new Hono2();
+var pendingElicitations = /* @__PURE__ */ new Map();
+tools.post("/", async (c) => {
+  let client = null;
+  let encoder = null;
+  let streamController = null;
+  let action;
+  let toolName;
+  try {
+    const requestData = await c.req.json();
+    action = requestData.action;
+    toolName = requestData.toolName;
+    const { serverConfig, parameters, requestId, response } = requestData;
+    if (!action || !["list", "execute", "respond"].includes(action)) {
+      return c.json(
+        {
+          success: false,
+          error: "Action must be 'list', 'execute', or 'respond'"
+        },
+        400
+      );
+    }
+    if (action === "respond") {
+      if (!requestId) {
+        return c.json(
+          {
+            success: false,
+            error: "requestId is required for respond action"
+          },
+          400
+        );
+      }
+      const pending = pendingElicitations.get(requestId);
+      if (!pending) {
+        return c.json(
+          {
+            success: false,
+            error: "No pending elicitation found for this requestId"
+          },
+          404
+        );
+      }
+      pending.resolve(response);
+      pendingElicitations.delete(requestId);
+      return c.json({ success: true });
+    }
+    const validation = validateServerConfig(serverConfig);
+    if (!validation.success) {
+      return c.json(
+        { success: false, error: validation.error.message },
+        validation.error.status
+      );
+    }
+    encoder = new TextEncoder();
+    const readableStream = new ReadableStream({
+      async start(controller) {
+        streamController = controller;
+        try {
+          const clientId = `tools-${action}-${Date.now()}`;
+          client = createMCPClient(validation.config, clientId);
+          if (action === "list") {
+            controller.enqueue(
+              encoder.encode(
+                `data: ${JSON.stringify({
+                  type: "tools_loading",
+                  message: "Fetching tools from server..."
+                })}
+
+`
+              )
+            );
+            const tools2 = await client.getTools();
+            const toolsWithJsonSchema = Object.fromEntries(
+              Object.entries(tools2).map(([toolName2, tool]) => {
+                return [
+                  toolName2,
+                  {
+                    ...tool,
+                    inputSchema: zodToJsonSchema(
+                      tool.inputSchema
+                    )
+                  }
+                ];
+              })
+            );
+            controller.enqueue(
+              encoder.encode(
+                `data: ${JSON.stringify({
+                  type: "tools_list",
+                  tools: toolsWithJsonSchema
+                })}
+
+`
+              )
+            );
+          } else if (action === "execute") {
+            if (!toolName) {
+              controller.enqueue(
+                encoder.encode(
+                  `data: ${JSON.stringify({
+                    type: "tool_error",
+                    error: "Tool name is required for execution"
+                  })}
+
+`
+                )
+              );
+              return;
+            }
+            controller.enqueue(
+              encoder.encode(
+                `data: ${JSON.stringify({
+                  type: "tool_executing",
+                  toolName,
+                  parameters: parameters || {},
+                  message: "Executing tool..."
+                })}
+
+`
+              )
+            );
+            const tools2 = await client.getTools();
+            const tool = tools2[toolName];
+            if (!tool) {
+              controller.enqueue(
+                encoder.encode(
+                  `data: ${JSON.stringify({
+                    type: "tool_error",
+                    error: `Tool '${toolName}' not found`
+                  })}
+
+`
+                )
+              );
+              return;
+            }
+            const toolArgs = parameters && typeof parameters === "object" ? parameters : {};
+            const elicitationHandler = async (elicitationRequest) => {
+              const requestId2 = `elicit_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+              if (streamController && encoder) {
+                streamController.enqueue(
+                  encoder.encode(
+                    `data: ${JSON.stringify({
+                      type: "elicitation_request",
+                      requestId: requestId2,
+                      message: elicitationRequest.message,
+                      schema: elicitationRequest.requestedSchema,
+                      timestamp: /* @__PURE__ */ new Date()
+                    })}
+
+`
+                  )
+                );
+              }
+              return new Promise((resolve, reject) => {
+                pendingElicitations.set(requestId2, { resolve, reject });
+                setTimeout(() => {
+                  if (pendingElicitations.has(requestId2)) {
+                    pendingElicitations.delete(requestId2);
+                    reject(new Error("Elicitation timeout"));
+                  }
+                }, 3e5);
+              });
+            };
+            if (client.elicitation && client.elicitation.onRequest) {
+              const serverName = "server";
+              client.elicitation.onRequest(serverName, elicitationHandler);
+            }
+            const result = await tool.execute({
+              context: toolArgs
+            });
+            controller.enqueue(
+              encoder.encode(
+                `data: ${JSON.stringify({
+                  type: "tool_result",
+                  toolName,
+                  result
+                })}
+
+`
+              )
+            );
+            controller.enqueue(
+              encoder.encode(
+                `data: ${JSON.stringify({
+                  type: "elicitation_complete",
+                  toolName
+                })}
+
+`
+              )
+            );
+          }
+          controller.enqueue(encoder.encode(`data: [DONE]
+
+`));
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : "Unknown error";
+          controller.enqueue(
+            encoder.encode(
+              `data: ${JSON.stringify({
+                type: "tool_error",
+                error: errorMsg
+              })}
+
+`
+            )
+          );
+        } finally {
+          if (client) {
+            await client.disconnect();
+          }
+          controller.close();
+        }
+      }
+    });
+    return new Response(readableStream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      }
+    });
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : "Unknown error";
+    if (client) {
+      try {
+        await client.disconnect();
+      } catch (cleanupError) {
+      }
+    }
+    return c.json(
+      {
+        success: false,
+        error: errorMsg
+      },
+      500
+    );
+  }
+});
+var tools_default = tools;
+
+// routes/mcp/resources.ts
+import { Hono as Hono3 } from "hono";
+var resources = new Hono3();
+resources.post("/list", async (c) => {
+  try {
+    const { serverConfig } = await c.req.json();
+    const validation = validateServerConfig(serverConfig);
+    if (!validation.success) {
+      return c.json(
+        { success: false, error: validation.error.message },
+        validation.error.status
+      );
+    }
+    const client = createMCPClient(
+      validation.config,
+      `resources-list-${Date.now()}`
+    );
+    try {
+      const resources2 = await client.resources.list();
+      await client.disconnect();
+      return c.json({ resources: resources2 });
+    } catch (error) {
+      await client.disconnect();
+      throw error;
+    }
+  } catch (error) {
+    console.error("Error fetching resources:", error);
+    return c.json(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      },
+      500
+    );
+  }
+});
+resources.post("/read", async (c) => {
+  try {
+    const { serverConfig, uri } = await c.req.json();
+    const validation = validateServerConfig(serverConfig);
+    if (!validation.success) {
+      return c.json(
+        { success: false, error: validation.error.message },
+        validation.error.status
+      );
+    }
+    if (!uri) {
+      return c.json(
+        {
+          success: false,
+          error: "Resource URI is required"
+        },
+        400
+      );
+    }
+    const client = createMCPClient(
+      validation.config,
+      `resources-read-${Date.now()}`
+    );
+    try {
+      const content = await client.resources.read("server", uri);
+      await client.disconnect();
+      return c.json({ content });
+    } catch (error) {
+      await client.disconnect();
+      throw error;
+    }
+  } catch (error) {
+    console.error("Error reading resource:", error);
+    return c.json(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      },
+      500
+    );
+  }
+});
+var resources_default = resources;
+
+// routes/mcp/prompts.ts
+import { Hono as Hono4 } from "hono";
+var prompts = new Hono4();
+prompts.post("/list", async (c) => {
+  try {
+    const { serverConfig } = await c.req.json();
+    const validation = validateServerConfig(serverConfig);
+    if (!validation.success) {
+      return c.json(
+        { success: false, error: validation.error.message },
+        validation.error.status
+      );
+    }
+    const client = createMCPClient(
+      validation.config,
+      `prompts-list-${Date.now()}`
+    );
+    try {
+      const prompts2 = await client.prompts.list();
+      await client.disconnect();
+      return c.json({ prompts: prompts2 });
+    } catch (error) {
+      await client.disconnect();
+      throw error;
+    }
+  } catch (error) {
+    console.error("Error fetching prompts:", error);
+    return c.json(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      },
+      500
+    );
+  }
+});
+prompts.post("/get", async (c) => {
+  try {
+    const { serverConfig, name, args } = await c.req.json();
+    const validation = validateServerConfig(serverConfig);
+    if (!validation.success) {
+      return c.json(
+        { success: false, error: validation.error.message },
+        validation.error.status
+      );
+    }
+    if (!name) {
+      return c.json(
+        {
+          success: false,
+          error: "Prompt name is required"
+        },
+        400
+      );
+    }
+    const client = createMCPClient(
+      validation.config,
+      `prompts-get-${Date.now()}`
+    );
+    try {
+      const content = await client.prompts.get({
+        serverName: "server",
+        name,
+        args: args || {}
+      });
+      await client.disconnect();
+      return c.json({ content });
+    } catch (error) {
+      await client.disconnect();
+      throw error;
+    }
+  } catch (error) {
+    console.error("Error getting prompt:", error);
+    return c.json(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      },
+      500
+    );
+  }
+});
+var prompts_default = prompts;
+
+// routes/mcp/chat.ts
+import { Hono as Hono5 } from "hono";
+import { Agent } from "@mastra/core/agent";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createOllama } from "ollama-ai-provider";
+import { MCPClient as MCPClient2 } from "@mastra/mcp";
+var chat = new Hono5();
+var pendingElicitations2 = /* @__PURE__ */ new Map();
+chat.post("/", async (c) => {
+  let client = null;
+  try {
+    const requestData = await c.req.json();
+    const {
+      serverConfigs,
+      model,
+      apiKey,
+      systemPrompt,
+      messages,
+      ollamaBaseUrl,
+      action,
+      requestId,
+      response
+    } = requestData;
+    if (action === "elicitation_response") {
+      if (!requestId) {
+        return c.json(
+          {
+            success: false,
+            error: "requestId is required for elicitation_response action"
+          },
+          400
+        );
+      }
+      const pending = pendingElicitations2.get(requestId);
+      if (!pending) {
+        return c.json(
+          {
+            success: false,
+            error: "No pending elicitation found for this requestId"
+          },
+          404
+        );
+      }
+      pending.resolve(response);
+      pendingElicitations2.delete(requestId);
+      return c.json({ success: true });
+    }
+    if (!model || !model.id || !apiKey || !messages) {
+      return c.json(
+        {
+          success: false,
+          error: "model (with id), apiKey, and messages are required"
+        },
+        400
+      );
+    }
+    if (serverConfigs && Object.keys(serverConfigs).length > 0) {
+      const validation = validateMultipleServerConfigs(serverConfigs);
+      if (!validation.success) {
+        return c.json(
+          {
+            success: false,
+            error: validation.error.message,
+            details: validation.errors
+          },
+          validation.error.status
+        );
+      }
+      client = createMCPClientWithMultipleConnections(validation.validConfigs);
+    } else {
+      client = new MCPClient2({
+        id: `chat-${Date.now()}`,
+        servers: {}
+      });
+    }
+    const tools2 = await client.getTools();
+    const llmModel = getLlmModel(model, apiKey, ollamaBaseUrl);
+    let toolCallId = 0;
+    let streamController = null;
+    let encoder = null;
+    const elicitationHandler = async (elicitationRequest) => {
+      const requestId2 = `elicit_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+      if (streamController && encoder) {
+        streamController.enqueue(
+          encoder.encode(
+            `data: ${JSON.stringify({
+              type: "elicitation_request",
+              requestId: requestId2,
+              message: elicitationRequest.message,
+              schema: elicitationRequest.requestedSchema,
+              timestamp: /* @__PURE__ */ new Date()
+            })}
+
+`
+          )
+        );
+      }
+      return new Promise((resolve, reject) => {
+        pendingElicitations2.set(requestId2, { resolve, reject });
+        setTimeout(() => {
+          if (pendingElicitations2.has(requestId2)) {
+            pendingElicitations2.delete(requestId2);
+            reject(new Error("Elicitation timeout"));
+          }
+        }, 3e5);
+      });
+    };
+    if (client.elicitation && client.elicitation.onRequest && serverConfigs) {
+      for (const serverName of Object.keys(serverConfigs)) {
+        const normalizedName = serverName.toLowerCase().replace(/[\s\-]+/g, "_").replace(/[^a-z0-9_]/g, "");
+        client.elicitation.onRequest(normalizedName, elicitationHandler);
+      }
+    }
+    const originalTools = tools2 && Object.keys(tools2).length > 0 ? tools2 : {};
+    const wrappedTools = {};
+    for (const [name, tool] of Object.entries(originalTools)) {
+      wrappedTools[name] = {
+        ...tool,
+        execute: async (params) => {
+          const currentToolCallId = ++toolCallId;
+          if (streamController && encoder) {
+            streamController.enqueue(
+              encoder.encode(
+                `data: ${JSON.stringify({
+                  type: "tool_call",
+                  toolCall: {
+                    id: currentToolCallId,
+                    name,
+                    parameters: params,
+                    timestamp: /* @__PURE__ */ new Date(),
+                    status: "executing"
+                  }
+                })}
+
+`
+              )
+            );
+          }
+          try {
+            const result = await tool.execute(params);
+            if (streamController && encoder) {
+              streamController.enqueue(
+                encoder.encode(
+                  `data: ${JSON.stringify({
+                    type: "tool_result",
+                    toolResult: {
+                      id: currentToolCallId,
+                      toolCallId: currentToolCallId,
+                      result,
+                      timestamp: /* @__PURE__ */ new Date()
+                    }
+                  })}
+
+`
+                )
+              );
+            }
+            return result;
+          } catch (error) {
+            if (streamController && encoder) {
+              streamController.enqueue(
+                encoder.encode(
+                  `data: ${JSON.stringify({
+                    type: "tool_result",
+                    toolResult: {
+                      id: currentToolCallId,
+                      toolCallId: currentToolCallId,
+                      error: error instanceof Error ? error.message : String(error),
+                      timestamp: /* @__PURE__ */ new Date()
+                    }
+                  })}
+
+`
+                )
+              );
+            }
+            throw error;
+          }
+        }
+      };
+    }
+    const agent = new Agent({
+      name: "MCP Chat Agent",
+      instructions: systemPrompt || "You are a helpful assistant with access to MCP tools.",
+      model: llmModel,
+      tools: Object.keys(wrappedTools).length > 0 ? wrappedTools : void 0
+    });
+    const formattedMessages = messages.map((msg) => ({
+      role: msg.role,
+      content: msg.content
+    }));
+    const stream = await agent.stream(formattedMessages, {
+      maxSteps: 10
+      // Allow up to 10 steps for tool usage
+    });
+    encoder = new TextEncoder();
+    const readableStream = new ReadableStream({
+      async start(controller) {
+        streamController = controller;
+        try {
+          let hasContent = false;
+          for await (const chunk of stream.textStream) {
+            if (chunk && chunk.trim()) {
+              hasContent = true;
+              controller.enqueue(
+                encoder.encode(
+                  `data: ${JSON.stringify({ type: "text", content: chunk })}
+
+`
+                )
+              );
+            }
+          }
+          if (!hasContent) {
+            controller.enqueue(
+              encoder.encode(
+                `data: ${JSON.stringify({ type: "text", content: "I apologize, but I couldn't generate a response. Please try again." })}
+
+`
+              )
+            );
+          }
+          controller.enqueue(
+            encoder.encode(
+              `data: ${JSON.stringify({
+                type: "elicitation_complete"
+              })}
+
+`
+            )
+          );
+          controller.enqueue(encoder.encode(`data: [DONE]
+
+`));
+        } catch (error) {
+          console.error("Streaming error:", error);
+          controller.enqueue(
+            encoder.encode(
+              `data: ${JSON.stringify({
+                type: "error",
+                error: error instanceof Error ? error.message : "Unknown error"
+              })}
+
+`
+            )
+          );
+        } finally {
+          if (client) {
+            try {
+              await client.disconnect();
+            } catch (cleanupError) {
+              console.warn(
+                "Error cleaning up MCP client after streaming:",
+                cleanupError
+              );
+            }
+          }
+          controller.close();
+        }
+      }
+    });
+    return new Response(readableStream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      }
+    });
+  } catch (error) {
+    console.error("Error in chat API:", error);
+    if (client) {
+      try {
+        await client.disconnect();
+      } catch (cleanupError) {
+        console.warn("Error cleaning up MCP client after error:", cleanupError);
+      }
+    }
+    return c.json(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      },
+      500
+    );
+  }
+});
+var getLlmModel = (modelDefinition, apiKey, ollamaBaseUrl) => {
+  if (!modelDefinition || !modelDefinition.id || !modelDefinition.provider) {
+    throw new Error(
+      `Invalid model definition: ${JSON.stringify(modelDefinition)}`
+    );
+  }
+  switch (modelDefinition.provider) {
+    case "anthropic":
+      return createAnthropic({ apiKey })(modelDefinition.id);
+    case "openai":
+      return createOpenAI({ apiKey })(modelDefinition.id);
+    case "ollama":
+      const baseUrl = ollamaBaseUrl || "http://localhost:11434";
+      return createOllama({
+        baseURL: `${baseUrl}/api`
+        // Configurable Ollama API endpoint
+      })(modelDefinition.id, {
+        simulateStreaming: true
+        // Enable streaming for Ollama models
+      });
+    default:
+      throw new Error(
+        `Unsupported provider: ${modelDefinition.provider} for model: ${modelDefinition.id}`
+      );
+  }
+};
+var chat_default = chat;
+
+// routes/mcp/oauth.ts
+import { Hono as Hono6 } from "hono";
+var oauth = new Hono6();
+oauth.get("/metadata", async (c) => {
+  try {
+    const url = c.req.query("url");
+    if (!url) {
+      return c.json({ error: "Missing url parameter" }, 400);
+    }
+    let metadataUrl;
+    try {
+      metadataUrl = new URL(url);
+      if (metadataUrl.protocol !== "https:") {
+        return c.json({ error: "Only HTTPS URLs are allowed" }, 400);
+      }
+    } catch (error) {
+      return c.json({ error: "Invalid URL format" }, 400);
+    }
+    const response = await fetch(metadataUrl.toString(), {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        "User-Agent": "MCP-Inspector/1.0"
+      }
+    });
+    if (!response.ok) {
+      return c.json(
+        {
+          error: `Failed to fetch OAuth metadata: ${response.status} ${response.statusText}`
+        },
+        response.status
+      );
+    }
+    const metadata = await response.json();
+    return c.json(metadata);
+  } catch (error) {
+    console.error("OAuth metadata proxy error:", error);
+    return c.json(
+      {
+        error: error instanceof Error ? error.message : "Unknown error occurred"
+      },
+      500
+    );
+  }
+});
+var oauth_default = oauth;
+
+// routes/mcp/index.ts
+var mcp = new Hono7();
+mcp.get("/health", (c) => {
+  return c.json({
+    service: "MCP API",
+    status: "ready",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+});
+mcp.route("/chat", chat_default);
+mcp.route("/connect", connect_default);
+mcp.route("/tools", tools_default);
+mcp.route("/resources", resources_default);
+mcp.route("/prompts", prompts_default);
+mcp.route("/oauth", oauth_default);
+var mcp_default = mcp;
+
+// index.ts
+function logBox(content, title) {
+  const lines = content.split("\n");
+  const maxLength = Math.max(...lines.map((line) => line.length));
+  const width = maxLength + 4;
+  console.log("\u250C" + "\u2500".repeat(width) + "\u2510");
+  if (title) {
+    const titlePadding = Math.floor((width - title.length - 2) / 2);
+    console.log(
+      "\u2502" + " ".repeat(titlePadding) + title + " ".repeat(width - title.length - titlePadding) + "\u2502"
+    );
+    console.log("\u251C" + "\u2500".repeat(width) + "\u2524");
+  }
+  lines.forEach((line) => {
+    const padding = width - line.length - 2;
+    console.log("\u2502 " + line + " ".repeat(padding) + " \u2502");
+  });
+  console.log("\u2514" + "\u2500".repeat(width) + "\u2518");
+}
+var app = new Hono8();
+app.use("*", logger());
+var serverPort = process.env.PORT || "3001";
+var corsOrigins = [
+  `http://localhost:${serverPort}`,
+  "http://localhost:3000",
+  // Keep for development
+  "http://localhost:3001"
+  // Keep for development
+];
+app.use(
+  "*",
+  cors({
+    origin: corsOrigins,
+    credentials: true
+  })
+);
+app.route("/api/mcp", mcp_default);
+app.get("/health", (c) => {
+  return c.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+});
+if (process.env.NODE_ENV === "production") {
+  app.use("/*", serveStatic({ root: "./dist/client" }));
+  app.get("*", async (c) => {
+    const path = c.req.path;
+    if (path.startsWith("/api/")) {
+      return c.notFound();
+    }
+    const indexPath = join(process.cwd(), "dist", "client", "index.html");
+    const htmlContent = readFileSync(indexPath, "utf-8");
+    return c.html(htmlContent);
+  });
+} else {
+  app.get("/", (c) => {
+    return c.json({
+      message: "MCP Inspector API Server",
+      environment: "development",
+      frontend: `http://localhost:${serverPort}`
+    });
+  });
+}
+var port = parseInt(process.env.PORT || "3001");
+logBox(`http://localhost:${port}`, "\u{1F680} Inspector Launched");
+var server = serve({
+  fetch: app.fetch,
+  port,
+  hostname: "0.0.0.0"
+  // Bind to all interfaces for Docker
+});
+process.on("SIGINT", () => {
+  console.log("\n\u{1F6D1} Shutting down gracefully...");
+  server.close();
+  process.exit(0);
+});
+process.on("SIGTERM", () => {
+  console.log("\n\u{1F6D1} Shutting down gracefully...");
+  server.close();
+  process.exit(0);
+});
+var index_default = app;
+export {
+  index_default as default
+};
+//# sourceMappingURL=index.js.map